{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "start_time": "2023-07-07T09:52:25.481692Z",
     "end_time": "2023-07-07T09:52:25.508619Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "import rl_utils\n",
    "import copy\n",
    "from torch import nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "def compute_advantage(gamma, lmbda, td_delta):\n",
    "    td_delta = td_delta.detach().numpy()\n",
    "    advantage_list = []\n",
    "    advantage = 0.0\n",
    "    for delta in td_delta[::-1]:\n",
    "        advantage = gamma * lmbda * advantage + delta\n",
    "        advantage_list.append(advantage)\n",
    "    advantage_list.reverse()\n",
    "    return torch.tensor(advantage_list, dtype=torch.float)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-07-07T09:48:36.054592Z",
     "end_time": "2023-07-07T09:48:36.073544Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "class PolicyNet(nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-07-07T10:45:12.701800Z",
     "end_time": "2023-07-07T10:45:12.711772Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [
    "class ValueNet(nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-07-07T10:45:13.075371Z",
     "end_time": "2023-07-07T10:45:13.095322Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-07-07T10:45:13.836364Z",
     "end_time": "2023-07-07T10:45:13.848331Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [],
   "source": [
    "class TRPO:\n",
    "    \"\"\"\n",
    "    TRPO算法\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, hidden_dim, state_space, action_space, lmbda, kl_constraint, alpha, critic_lr, gamma, device):\n",
    "        state_dim = state_space.shape[0]\n",
    "        action_dim = action_space.n\n",
    "        # 策略网络不需要优化器更新\n",
    "        self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        self.critic = ValueNet(state_dim, hidden_dim).to(device)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        self.lmbda = lmbda\n",
    "        self.kl_constraint = kl_constraint\n",
    "        self.alpha = alpha\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "\n",
    "    def hessian_matrix_vector_product(self, states, old_action_dists, vector):\n",
    "        # 计算黑塞矩阵和一个向量的乘积\n",
    "        new_action_dists = torch.distributions.Categorical(self.actor(states))\n",
    "        kl = torch.mean(\n",
    "            torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                 new_action_dists))  # 计算平均KL距离\n",
    "        kl_grad = torch.autograd.grad(kl,\n",
    "                                      self.actor.parameters(),\n",
    "                                      create_graph=True)\n",
    "        kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])\n",
    "        # KL距离的梯度先和向量进行点积运算\n",
    "        kl_grad_vector_product = torch.dot(kl_grad_vector, vector)\n",
    "        grad2 = torch.autograd.grad(kl_grad_vector_product,\n",
    "                                    self.actor.parameters())\n",
    "        grad2_vector = torch.cat([grad.view(-1) for grad in grad2])\n",
    "        return grad2_vector\n",
    "\n",
    "    def conjugate_gradient(self, grad, states, old_action_dists):  # 共轭梯度法求解方程\n",
    "        \"\"\"\n",
    "        共轭梯度求解方法\n",
    "        :param grad:\n",
    "        :param states:\n",
    "        :param old_action_dists:\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        x = torch.zeros_like(grad)\n",
    "        r = grad.clone()\n",
    "        p = grad.clone()\n",
    "        rdotr = torch.dot(r, r)\n",
    "        for i in range(10):  # 共轭梯度主循环\n",
    "            Hp = self.hessian_matrix_vector_product(states, old_action_dists,\n",
    "                                                    p)\n",
    "            alpha = rdotr / torch.dot(p, Hp)\n",
    "            x += alpha * p\n",
    "            r -= alpha * Hp\n",
    "            new_rdotr = torch.dot(r, r)\n",
    "            if new_rdotr < 1e-10:\n",
    "                break\n",
    "            beta = new_rdotr / rdotr\n",
    "            p = r + beta * p\n",
    "            rdotr = new_rdotr\n",
    "        return x\n",
    "\n",
    "    def compute_surrogate_obj(self, states, actions, advantage, old_log_probs,\n",
    "                              actor):  # 计算策略目标\n",
    "        log_probs = torch.log(actor(states).gather(1, actions))\n",
    "        ratio = torch.exp(log_probs - old_log_probs)\n",
    "        return torch.mean(ratio * advantage)\n",
    "\n",
    "    def line_search(self, states, actions, advantage, old_log_probs,\n",
    "                    old_action_dists, max_vec):  # 线性搜索\n",
    "        old_para = torch.nn.utils.convert_parameters.parameters_to_vector(\n",
    "            self.actor.parameters())\n",
    "        old_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                             old_log_probs, self.actor)\n",
    "        for i in range(15):  # 线性搜索主循环\n",
    "            coef = self.alpha ** i\n",
    "            new_para = old_para + coef * max_vec\n",
    "            new_actor = copy.deepcopy(self.actor)\n",
    "            torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "                new_para, new_actor.parameters())\n",
    "            new_action_dists = torch.distributions.Categorical(\n",
    "                new_actor(states))\n",
    "            kl_div = torch.mean(\n",
    "                torch.distributions.kl.kl_divergence(old_action_dists,\n",
    "                                                     new_action_dists))\n",
    "            new_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                 old_log_probs, new_actor)\n",
    "            if new_obj > old_obj and kl_div < self.kl_constraint:\n",
    "                return new_para\n",
    "        return old_para\n",
    "\n",
    "    def policy_learn(self, states, actions, old_action_dists, old_log_probs,\n",
    "                     advantage):  # 更新策略函数\n",
    "        surrogate_obj = self.compute_surrogate_obj(states, actions, advantage,\n",
    "                                                   old_log_probs, self.actor)\n",
    "        grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())\n",
    "        obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()\n",
    "        # 用共轭梯度法计算x = H^(-1)g\n",
    "        descent_direction = self.conjugate_gradient(obj_grad, states,\n",
    "                                                    old_action_dists)\n",
    "\n",
    "        Hd = self.hessian_matrix_vector_product(states, old_action_dists,\n",
    "                                                descent_direction)\n",
    "        max_coef = torch.sqrt(2 * self.kl_constraint /\n",
    "                              (torch.dot(descent_direction, Hd) + 1e-8))\n",
    "        new_para = self.line_search(states, actions, advantage, old_log_probs,\n",
    "                                    old_action_dists,\n",
    "                                    descent_direction * max_coef)  # 线性搜索\n",
    "        torch.nn.utils.convert_parameters.vector_to_parameters(\n",
    "            new_para, self.actor.parameters())  # 用线性搜索后的参数更新策略\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(\n",
    "            self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        td_target = rewards + self.gamma * self.critic(next_states) * (1 -\n",
    "                                                                       dones)\n",
    "        td_delta = td_target - self.critic(states)\n",
    "        advantage = compute_advantage(self.gamma, self.lmbda,\n",
    "                                      td_delta.cpu()).to(self.device)\n",
    "        old_log_probs = torch.log(self.actor(states).gather(1,\n",
    "                                                            actions)).detach()\n",
    "        old_action_dists = torch.distributions.Categorical(\n",
    "            self.actor(states).detach())\n",
    "        critic_loss = torch.mean(\n",
    "            F.mse_loss(self.critic(states), td_target.detach()))\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()  # 更新价值函数\n",
    "        # 更新策略函数\n",
    "        self.policy_learn(states, actions, old_action_dists, old_log_probs,\n",
    "                          advantage)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-07-07T10:45:14.281182Z",
     "end_time": "2023-07-07T10:45:14.337032Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/50 [00:00<?, ?it/s]C:\\Users\\14227\\AppData\\Local\\Temp\\ipykernel_14080\\1290935865.py:20: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ..\\torch\\csrc\\utils\\tensor_new.cpp:248.)\n",
      "  state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
      "C:\\Users\\14227\\AppData\\Local\\Temp\\ipykernel_14080\\3338725462.py:9: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  return F.softmax(self.fc2(x))\n",
      "E:\\PCL\\PyCharm 2023.1\\jbr\\bin\\D\\code\\env\\lib\\site-packages\\gym\\utils\\passive_env_checker.py:241: DeprecationWarning: `np.bool8` is a deprecated alias for `np.bool_`.  (Deprecated NumPy 1.24)\n",
      "  if not isinstance(terminated, (bool, np.bool8)):\n",
      "Iteration 0: 100%|██████████| 50/50 [00:11<00:00,  4.34it/s, episode=50, return=51.800]\n",
      "Iteration 1: 100%|██████████| 50/50 [00:09<00:00,  5.22it/s, episode=100, return=73.600]\n",
      "Iteration 2: 100%|██████████| 50/50 [00:11<00:00,  4.51it/s, episode=150, return=98.100]\n",
      "Iteration 3: 100%|██████████| 50/50 [00:12<00:00,  3.88it/s, episode=200, return=126.200]\n",
      "Iteration 4: 100%|██████████| 50/50 [00:13<00:00,  3.61it/s, episode=250, return=134.100]\n",
      "Iteration 5: 100%|██████████| 50/50 [00:15<00:00,  3.16it/s, episode=300, return=142.400]\n",
      "Iteration 6: 100%|██████████| 50/50 [00:17<00:00,  2.79it/s, episode=350, return=168.700]\n",
      "Iteration 7: 100%|██████████| 50/50 [00:18<00:00,  2.69it/s, episode=400, return=179.200]\n",
      "Iteration 8: 100%|██████████| 50/50 [00:19<00:00,  2.54it/s, episode=450, return=191.900]\n",
      "Iteration 9: 100%|██████████| 50/50 [00:19<00:00,  2.51it/s, episode=500, return=188.700]\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC/VklEQVR4nOydd5wU5f3HP7P1+h0H3B0nHQSkigiIhaJYEFvURAnGLmqwJ2pIjD3BnybGGEs0MZZExdiNBUUQbIBIEbAgHRSOo12/29syvz92Z/Z5Zp5pu3u7e3ff9+t1ujvlmWdmj30+962SLMsyCIIgCIIgOiiuTE+AIAiCIAiiLSGxQxAEQRBEh4bEDkEQBEEQHRoSOwRBEARBdGhI7BAEQRAE0aEhsUMQBEEQRIeGxA5BEARBEB0aEjsEQRAEQXRoSOwQBEEQBNGhIbFDEASRpVx88cXo27dvpqdBEO0eEjsEkUVIkmTrZ/Hixdi2bRu3zeVyobS0FNOmTcPSpUt1Y995553c8Xl5eRg6dChuu+021NXV6Y7/+uuvccEFF+CQQw6B3+9HZWUlZs6cia+//jodj8Ixe/bswa9//WsMGTIEeXl5yM/Px5gxY3DvvfeipqYmpdd67LHH8Mwzz+i2L168mHvGXq8X/fv3x4UXXogtW7akdA5tTU1NDWbNmoXu3bsjPz8fU6ZMwapVqzI9LYJICE+mJ0AQRJx///vf3PvnnnsOCxYs0G0/7LDD0NzcDACYMWMGTj31VITDYXz//fd47LHHMGXKFKxYsQIjRozQXePxxx9HQUEBGhoa8MEHH+APf/gDFi1ahM8++wySJAEAXnvtNcyYMQOlpaW47LLL0K9fP2zbtg1PPfUUXnnlFcybNw8/+clP2ugpOGfFihU49dRT0dDQgAsuuABjxowBAHz55Ze477778PHHH+ODDz5I2fUee+wxdOvWDRdffLFw/3XXXYexY8ciGAxi1apVePLJJ/HOO+9g3bp1qKysTNk82opIJILp06fjq6++ws0334xu3brhsccew+TJk7Fy5UoceuihmZ4iQThDJggia5k9e7Zs9M9069atMgD5gQce4La/9957MgD56quv5rbfcccdMgB579693Pazzz5bBiB//vnnsizL8qZNm+S8vDx5yJAhcnV1NXfs3r175SFDhsj5+fny5s2bk729lHDw4EH5kEMOkcvLy+Vvv/1Wt7+qqkq+5557UnKtxsZGWZZlediwYfKkSZN0+z/66CMZgPzyyy9z2x9++GEZgPzHP/7R0fUuuugiuU+fPolON2Feeukl3X1UV1fLJSUl8owZM9I+H4JIFnJjEUQH47jjjgMAbN682dbxxx9/PABg69atAIAHHngATU1NePLJJ9G9e3fu2G7duuGJJ55AY2Mj7r//fsuxq6urcdlll6G8vBw5OTkYNWoUnn32We4YxR33pz/9CU8++SQGDBgAv9+PsWPHYsWKFZbXeOKJJ/Djjz/iwQcfxJAhQ3T7y8vLcdttt6nv33zzTUyfPh2VlZXw+/0YMGAA7rnnHoTDYe68yZMnY/jw4Vi5ciUmTpyIvLw8/Pa3v0Xfvn3x9ddfY8mSJaq7avLkyaZz1D5jIGodGjZsmOoinD17ti13WyQSwUMPPYRhw4YhJycH5eXluPLKK3Hw4EHT81555RVIkoQlS5bo9j3xxBOQJAnr169Xjy0vL8fZZ5+tHtO9e3f87Gc/w5tvvolAIGA5T4LIJsiNRRAdjG3btgEAunTpYut4RRR17doVAPC///0Pffv2VUWTlokTJ6Jv37545513TMdtbm7G5MmTsWnTJlxzzTXo168fXn75ZVx88cWoqanB9ddfzx3/wgsvoL6+HldeeSUkScL999+Ps88+G1u2bIHX6zW8zltvvYXc3Fyce+65tu73mWeeQUFBAW666SYUFBRg0aJFuP3221FXV4cHHniAO3b//v2YNm0azj//fFxwwQUoLy/H5MmTce2116KgoAC/+93vAEQFlRnaZ3znnXfirrvuwtSpU3H11Vdjw4YNePzxx7FixQp89tlnpvd75ZVX4plnnsEll1yC6667Dlu3bsUjjzyC1atXm547ffp0FBQU4L///S8mTZrE7XvppZcwbNgwDB8+HACwevVqHHHEEXC5+L+Hx40bhyeffBLff/+90EVKEFlLpk1LBEEYY8eNddddd8l79+6Vq6qq5E8++UQeO3as0JWiuLE2bNgg7927V966dav8xBNPyH6/Xy4vL5cbGxvlmpoaGYB85plnms7rjDPOkAHIdXV1hsc89NBDMgD5P//5j7qttbVVnjBhglxQUKCeq9xH165d5QMHDqjHvvnmmzIA+X//+5/pXLp06SKPGjXK9BiWpqYm3bYrr7xSzsvLk1taWtRtkyZNkgHIf//733XHW7mx/vWvf8l79+6Vd+3aJb/zzjty3759ZUmS5BUrVsjV1dWyz+eTTzrpJDkcDqvnPvLII+q5Clo31ieffCIDkJ9//nnuuvPnzxdu1zJjxgy5rKxMDoVC6rbdu3fLLpdLvvvuu9Vt+fn58qWXXqo7/5133pEByPPnzze9DkFkG+TGIoh2zh133IHu3bujoqICxx13HL799lv8+c9/NrR0DB48GN27d0e/fv1w5ZVXYuDAgXjnnXeQl5eH+vp6AEBhYaHpNZX9oiwuhXfffRcVFRWYMWOGus3r9eK6665DQ0ODzp1y3nnncdYoxbJklcVUV1dnOV+W3Nxc9XV9fT327duH4447Dk1NTfjuu++4Y/1+Py655BLbYytceuml6N69OyorKzF9+nQ0Njbi2WefxZFHHokPP/wQra2tuOGGGzjLyRVXXIGioiJTi9nLL7+M4uJinHjiidi3b5/6M2bMGBQUFOCjjz4yndd5552H6upqLF68WN32yiuvIBKJ4LzzzlO3NTc3w+/3687PyclR9xNEe4LcWATRzpk1axZ++tOfoqWlBYsWLcLDDz+siz9hefXVV1FUVASv14uePXtiwIAB6j5FNCiixwg7omj79u049NBDda6Qww47TN3P0rt3b+69InysYlGKioos58vy9ddf47bbbsOiRYt0Yq22tpZ7f8ghh8Dn89keW+H222/HcccdB7fbjW7duuGwww6DxxP9ulXue/Dgwdw5Pp8P/fv31z0Xlo0bN6K2thZlZWXC/dXV1ep9sILE5/OhtLQUp5xyCoqLi/HSSy/hhBNOABB1YR1++OEYNGiQenxubq4wLqelpUXdTxDtCRI7BNHOOfTQQzF16lQAwGmnnQa3243f/OY3mDJlCo488kjd8RMnTkS3bt2EYxUXF6NHjx5Yu3at6TXXrl2LQw45BEVFRcnfQAy32y3cLsuy6XlDhgzBmjVr0NraailMampqMGnSJBQVFeHuu+/GgAEDkJOTg1WrVuHWW29FJBLhjk90UR8xYoT6maSSSCSCsrIyPP/888L9SkD59ddfzwWCT5o0CYsXL4bf78dZZ52F119/HY899hj27NmDzz77DH/84x+5cXr06IHdu3frxle2tYf0eYJgIbFDEB2M3/3ud/jHP/6B2267DfPnz3d8/mmnnYZ//OMf+PTTT3Hsscfq9n/yySfYtm0brrzyStNx+vTpg7Vr1yISiXDWHcVV1KdPH8dzE3H66adj6dKlePXVVzmXmYjFixdj//79eO211zBx4kR1O5slZQelHlEiKPe9YcMG9O/fX93e2tqKrVu3moqkAQMG4MMPP8QxxxxjKsRuueUWXHDBBep71j143nnn4dlnn8XChQvx7bffQpZlzoUFAIcffjg++eQT3We3fPly5OXlcVYggmgPUMwOQXQwSkpKcOWVV+L999/HmjVrHJ9/8803Izc3F1deeSX279/P7Ttw4ACuuuoq5OXl4eabbzYd59RTT0VVVRVeeukldVsoFMLf/vY3FBQU6DKCEuWqq65Cjx498Ktf/Qrff/+9bn91dTXuvfdeAHHrEWstam1txWOPPebomvn5+QlXZZ46dSp8Ph8efvhhbh5PPfUUamtrMX36dMNzf/aznyEcDuOee+7R7QuFQuqchg4diqlTp6o/SpFF5fqlpaV46aWX8NJLL2HcuHHo168fN9a5556LPXv24LXXXlO37du3Dy+//DJOP/10YTwPQWQzZNkhiA7I9ddfj4ceegj33Xcf5s2b5+jcQw89FM8++yxmzpyJESNG6Coo79u3Dy+++CIX6yNi1qxZeOKJJ3DxxRdj5cqV6Nu3L1555RV89tlneOihhxwFFZvRpUsXvP766zj11FNx+OGHcxWUV61ahRdffBETJkwAABx99NHo0qULLrroIlx33XWQJAn//ve/LV1lWsaMGYPHH38c9957LwYOHIiysjK1lo4V3bt3x5w5c3DXXXfhlFNOwRlnnIENGzbgsccew9ixYzmLjJZJkybhyiuvxNy5c7FmzRqcdNJJ8Hq92LhxI15++WX89a9/tUzB93q9OPvsszFv3jw0NjbiT3/6k+6Yc889F0cddRQuueQSfPPNN2oF5XA4jLvuusvWfRJEVpHRXDCCIExJpIKywsUXXyy73W5506ZNsiwbV1A2Yu3atfKMGTPkHj16yF6vV66oqJBnzJghr1u3zvb89+zZI19yySVyt27dZJ/PJ48YMUJ++umnbd8HAPmOO+6wda1du3bJN954ozxo0CA5JydHzsvLk8eMGSP/4Q9/kGtra9XjPvvsM/moo46Sc3Nz5crKSvmWW26R33//fRmA/NFHH6nHTZo0SR42bJjwWlVVVfL06dPlwsJCGYCahm5UQVnEI488Ig8ZMkT2er1yeXm5fPXVV8sHDx7kjjGqoPzkk0/KY8aMkXNzc+XCwkJ5xIgR8i233CLv2rXL8rqyLMsLFiyQAciSJMk7d+4UHnPgwAH5sssuk7t27Srn5eXJkyZNklesWGFrfILINiRZdvgnDUEQBEEQRDuCYnYIgiAIgujQkNghCIIgCKJDQ2KHIAiCIIgODYkdgiAIgiA6NCR2CIIgCILo0JDYIQiCIAiiQ0NFBRHtN7Nr1y4UFhYmVQaeIAiCIIj0Icsy6uvrUVlZqWs6zEJiB8CuXbvQq1evTE+DIAiCIIgE2LlzJ3r27Gm4n8QOoJat37lzZ0q7OBMEQRAE0XbU1dWhV69elu1nSOwg3sG4qKiIxA5BEARBtDOsQlAoQJkgCIIgiA4NiR2CIAiCIDo0JHYIgiAIgujQkNghCIIgCKJDQ2KHIAiCIIgODYkdgiAIgiA6NCR2CIIgCILo0JDYIQiCIAiiQ0NihyAIgiCIDg2JHYIgCIIgOjQZFTtz587F2LFjUVhYiLKyMpx11lnYsGEDd0xLSwtmz56Nrl27oqCgAOeccw727NnDHbNjxw5Mnz4deXl5KCsrw80334xQKJTOWyEIgiAIIkvJqNhZsmQJZs+ejWXLlmHBggUIBoM46aST0NjYqB5z44034n//+x9efvllLFmyBLt27cLZZ5+t7g+Hw5g+fTpaW1vx+eef49lnn8UzzzyD22+/PRO3RBAEQRBEliHJsixnehIKe/fuRVlZGZYsWYKJEyeitrYW3bt3xwsvvIBzzz0XAPDdd9/hsMMOw9KlS3HUUUfhvffew2mnnYZdu3ahvLwcAPD3v/8dt956K/bu3Qufz2d53bq6OhQXF6O2tpYagRJpp7k1jFyfO9PT0JGt80qGlmAYfo/LsmmgnXF8bhdcLufjpPK5yrKMQCiCHK/1eOGIjFAkAr/HLXwO2nkp9xgIRYTzDYTCcEsSPG57fzOz4yfyDFpDEbgkqNdTxpBlGXvqAijK9SDP5zH9bELhCCRJgtvkc4tEZLSG489U+6wCoTD8HvHcW4Jh9TxZlrG7tgWl+T7u82HvvbquBbk+NwpzvLqxapuCaA1H0L3QrxurqTWEmqYgehTnQJIkNLeGkeN1oSUYgdctISIDPo/+c6mub0FrKILSfB/yfB7u/uqaQ6gPBFHg96Akz6c+r6q6FkiShMrYtdj7yPG6sKu2BYqMqCzOhcslpfW7w+76nVVdz2trawEApaWlAICVK1ciGAxi6tSp6jFDhgxB7969VbGzdOlSjBgxQhU6AHDyySfj6quvxtdff43Ro0frrhMIBBAIBNT3dXV1bXVLBGHK22t34ZoXVuP204bi0mP7ZXo6Kv9dsRO3vLoW958zEj8b2yvT00kJ1XUtGPfHhZg8uDueuWRcwuPUtwRxxD0LMLSyGG/OPsbRuXPf/RZPfLwFL181AWP7liY8B4XZL6zCu+uq8MktU9CrNM/02FMe+hi7aprx1rXH4oQ/L8GpIyrw2MwxAIDb3liH/yzbgbevPRbDDylGVW0LJj3wEfL9HhxobMV1JxyKm04cpI4VCIUx9t4P0bXAj49+Pdlynut/rMVpf/sUvziqD3qU5OD++Rvw9MVjMWVIma37bA1FMPYPH6Io14OPb56Chd9W4/LnvsRvTx2C6roA/vnpVhT6PXj3+uMw/eFP0K9bPt685lhujEhExsx/LseWfY1Y/OvJyPeLl79fPr8Kn2/eh8U3T0FzMIxj7luE00b2wCM/PwIPL9yIvy7ciBevOArj+vGf32eb9mHmP5fjllMG45eTB+K3r6/Hi1/sQJc8L5bcMgVFOV6s3H4Q5zz+OWZN7I/iXC8eeH8D/B4X3rv+OPTvXqCO9fnmffjFU18gHJFxz5nDsGZnLV5d9QO6Ffjw2tXHYPrfPkF9SwhnHl6JUT1LcPfb3yDP50ZTaxjFuV543RI+vfV4TmQ9+fFm/PHd7wAAhX4PFv16MiKyjKPvW4QueV7UNAURishwuyQ8ffFYHHdoN5z12GdY/2N0fTxlWAX+/ovo78uDH2zAw4s2oWu+D/sbW9VrTB7cHRdO6INLn/kSt00/DJcf19/W55sOsiZAORKJ4IYbbsAxxxyD4cOHAwCqqqrg8/lQUlLCHVteXo6qqir1GFboKPuVfSLmzp2L4uJi9adXr47xZU60P657cTUA4O63v8nwTHhueXUt9/+OwOurfwQALN6wN6lxlm7ej2BYxlc7axyf+8THWwAA9733XVJzUHh3XfQ77oUvdlgeu7G6AY2tYdz+5nruXAD4z7Lo+Q8v3AgAeObzbQiEIjgQW8iU7epYexpQ1xLC1n2NsOMceOjD6Pn/XrYd98+PxmXe6uB3a/v+RtQ2B7HzQDMiMvDrV74CAPzx3e+wJvY51AdCeOGLHahrCeGrH2p183pvfRWWbz2AvfUBbN/fZHitL7cfQF1LCN/trsPzy7YDAN5euxt76lrw4ILvEY7IeHfdbt15N78cndP98zfgy20HsGr7QQDAwaYgdsSud9973wIAnvx4C5ZvPQAACIQi2FBVz4217odahCPR+f/lw434ZGP0d3ZfQyveXrcL9S3RmNQ31+xSvzuaWsMAgNrmIPY1tGL1jhpuzDXM72t9IIQtexvw0oqdCEdk7GtoRSh2vXBExvpdtQiGZVXoAMDqnQfV1w8v2gQAqtDxuqMWn9U7anD9vDUAgHvf+Vb4fDNF1oid2bNnY/369Zg3b16bX2vOnDmora1Vf3bu3Nnm1yQIIrMk6bnKapzcmsdl/LUfW++wq6bZ/HrMBZVF2SlOzmKvF5Fl7h6CzPUjzOtAKMKN8ezSbdwYRjQEokJiX2Mrd92XVsTXie6Fft15tc1B9fW5f1+KDXviAiYYjsTuIz5gbVPcIhLWzCfE3MeBxlZU18c9EZurG2GHA4zFBdB/TqGIrM5LS0SwLxQ2fmb/vGhs7JiIKrqyjawQO9dccw3efvttfPTRR+jZs6e6vaKiAq2traipqeGO37NnDyoqKtRjtNlZynvlGC1+vx9FRUXcD0EQHRvJkSRoW1I9E5cDJecxi1eJLbpVtS2mY7DPUrtQ28XZacz1IjJ3D+FIfFEOMgtyfUsIBxpb8c9PtmBvfYBb/EMGAi0UjqAlGB3vQEOAe67c+YKFv9FkkVfm5WbGO9gUF0c6IWIiLDbvbTDcx3KgMcC91+qaUCw2SUQ4Ap3YMRJGAFCYE3UJBiNywuK3rcmo2JFlGddccw1ef/11LFq0CP368TELY8aMgdfrxcKFC9VtGzZswI4dOzBhwgQAwIQJE7Bu3TpUV1erxyxYsABFRUUYOnRoem6EIBIk2UBZwj6petSp+MxS/bFbjcdaPLwmAcWK2NlVmwbLjgO149JadtzxDSFO4MQFREMghF8+vxL3vvMtZj+/ilusWYHEwgqW/Y2tnNhhrUEhg/ONCKmWnfi2Gtayo3mGRvMD4mKn0CDmSOFAY5B7rx0zFI4gGBJ/BmFZL4SMBCIAFClix0QQZZqMBijPnj0bL7zwAt58800UFhaqMTbFxcXIzc1FcXExLrvsMtx0000oLS1FUVERrr32WkyYMAFHHXUUAOCkk07C0KFD8Ytf/AL3338/qqqqcNttt2H27Nnw+/WmRoIgiI6Gmdb54OsqvL02HmPCCgUtyqK728qywwxhtgjG0R9j5krSwooOrWWHvT7rSmpoCWHZlmhczBfbDuCQktz4OQaWk8ZAvD7b/sZWlBfmCK9jZBExQjmevY+6lvi1tM8waPJMlXidsiI/6vca15PTWXY0Q4Zi2Xkiom4s+9YmJZsse3K79WRU7Dz++OMAgMmTJ3Pbn376aVx88cUAgL/85S9wuVw455xzEAgEcPLJJ+Oxxx5Tj3W73Xj77bdx9dVXY8KECcjPz8dFF12Eu+++O123QRBEOyBVVrSstMWZ3Nusf6/k3ptZdmQ5anGxstawbqxIumN2IuDS3cMGYoe18gC8QDG6P07sNATQoygudlqCcauP2cIvQjne6GPSPsOQDTFVUZyDzXuN43f2NvBiR38N45idsCzr5hA0EEYuCchrByUqMip27Jgxc3Jy8Oijj+LRRx81PKZPnz549913Uzk1gkgLWblwdlCy6VmnOn7IWYAyL1RcLt5qUtdsXX3euWVHjxMrACeuZK1lJ74Ic2KHES5ul8Qt7EZzbmDOOdDYyj2bpkBc7Dz16VZ8/P1evPrLo1GU47Vcy5Q5Gglu7XyU9z63y9CKVM4IMRF76rQxO9prRNBq4MYSBSjLcnQMbY2iHK9bKKCzTQBlRYAyQRBEW9MW4VHZUpPVyb2xVhHtQhqRZU4waAlHZBxobOUWznTE7HAxQiYxO1o3lkKe180dZ2zZYWJ2Glq5OTa28iJwY3UDno+l7LMuKRGtsWsbxYZrXXrKXAtyjO0R1mKHd0WKgqC1gsYX+90IR2RVCOUytXpElqBcEjsEQRDZQ6q0DrvwJqx1Uh2g7GBALyMUtOnZEVk2jaW54aU1OOKeBVj/Y626LR2p5yyRCJ96bhSzw7qxcn1uTtgZWXZYQbOvIYBW5vmwVh91nNiY2jRvo+OMsua0bjFlfoVmYkeQ/s5SXRfgxJo2ay4qaPjPP8frUo9VhA1bCVn03HK8brhdkk5wKxWaswUSOwSRQSgZK320ReZbomnXqcbJrbELrnaxi8jmgcP/+2oXAOCvTJHBxC07wLZ9jfhy2wHLYyOaRZsVbOz12RovrDjJ87ntZWMx59S1hLjsrEaB2FGuvF8TH6MlqIod8X69ZSd6fIFJxpWVZac1HOGCjJXnpMwhGInorFWKsGHdWKxlRxRLpJzj1dRvIssOQRBEBkhd6nn8tZOMorbEya2xf+2L3Fh27uiHg/HU9MRjdmRM/tNinPv3pdi6z7xQHvuYtXEjRkG29Yxrye9xc2MYWnY0gqaKcQWxLi4tVpadoBqg7Cxmx8iy43O7UJpv3feR/XyV31WlZ1Y4IuvuVxE2bOo5a9nRZmix52iz/JzUfkoHJHYIgiASJFGtk+plwMm6wq6rOstORHYch5QKN9b3e+oNjwN4USnLfEaZ0fXZAGWvh39ARuc0aATNbqaStNYKwiISASxqnR2D/aLqxgC4BqHFufHXU4eWwSto9KmF/XyVayhNTENhWSfgcmOup2hRwXiQtBIQLkpVV8SONm4n24oLktghiAySTVV9Ozpt4sbKki90J/fGut7Ebixn107GjaVgZQVgr6C17GjjjhRYy462RYadOjsAX29I5MZS52QhEINqgLL4PvXBw9F7YgsHVjBuq2umHKpzG4kIhOJiRrmGYtkJRSK6OKTcWMxOJBJPPfd6XKrVRvTcchQ3lsay47TwYltDYocgiE5BW8jKRN1YmbTws3EX7GIIRBdEs3sqEwTFJrqosQ4zq8fBubE0vbGMxNY+pp+UdiE2tuzwiz+b0SSy3ijzsqo1pNSoMdIn2vko12LdWIU5Hrz2y6Px3ysnYGhlkWlxSIWL/7UCL3+5k7uGXxU7smHMDhug7HVJqrASZ2NF92kFZbb8IaBAYocgiE5BWwiMbPnj1cm9sX+d6y07sqlrLserDzpNdFFj52FlpGBdaxFNBWUj2HgbbW0YuzE7dm/NSvSGLGJ2jNpFsKnnOV43jujdBeP6lQLQCzgRG/bU4+ZXot3lFeuTKnbCxjE7kYispst73YxlR/BAjGJ2guFotpedAonpgMQOQWQS8mK1O7QF7jIFKwCcuEPZVgQisWN2T6J9CYsd5jwrNxznxpJl2Amj/pEJota1PjDsjRVd/O2Iqei8ouNaPYOgQeq5IjyMup6zMTtKWriCWfd6ERFNzE5Ta1j3XHKYAOVgiHVjxS072ntV3GLamJ0fa5px2O3zMebeD7HFZvPStoTEDkEQnQJ2oUmmGCC70CbsxkqByg1zYsHJeYwbS/NXdzhibtkR7bMjdqwek2XMjiYby841W03cdbtrW3TFE0PhCD7ZuA8A0LNLLuygurFsxuxo71JJzzbqes66sbTPyI4bS2HrvsZ4wHFMnIiKR7LzUQSazy3B64rH7GhdWcrvssjSFI5Ei1Qu32pdXqCtIbFDEESngP0qTsYgo40fSWguKbDohTnLjn3M3Vjmz0YkMhJNPWexmr82G8upNSkQ5O/z8cWbMequD7htc9/7Tg1q7t0139a4ioXIajpG6fF5avaT2PJkVmfHrMeZlil/WowfY5llijWpTiB2VDcWG7Pjjlt2QpGI4b2YWZq01ZwzAYkdgsgg5MVKH6mqj8OuS5kss8N6YpzUNGHFidMKyqJ9iTYCZbESjVrLjkhgscJgSEUht8+ovxRr4du+P17r57SRPUzno44be35W4kuJW9Hep5FlR7HCsAX9tFew62rT4o+NWdeiFzs5zHxEMTvBsGyYyWYWQ6Tt05UJSOwQBNHpSGZ95qr5ZjDjhLPs2OymDfBiR2vZscrGEu1LhWXHqos46zoMGwgyNqZlxCHF3D6tZUdB1ELigXNHon83e5Yd5flZurFiY2s/jzy/2LKjvGetN9pLeBxYdlgUyw5bbVpBLSoYAWfZUbKxzDqlm82nmiw7BNG5ybIiox2aVAUWc5lBGTTt2BFaIiHCZsdoxY5sUWdHtC8Vgs+ofYMC+5ijNWD4a3pcktrEEoCu4J6RZScgKLrndkm2qhOz41qmnseuo/088mLiQrtdERRmcTl2srFEKDE7orpBrBtL+T3xeaS4ZScS4QLcWcwsTXvqSewQBEGkhWxyY6VC5LILrN2UZkBr2dHX2TFr0SkaLxVix8o6ZBWg7HZJ6iIORBfeqycPUN8HguJWD6IKw26XhK4F5k024+fHsrEsHoFyf9p55/vjqd6i4/k4GK3AS86yI6oInWfoxmIsOxqBrPzqmcUQVZMbiyAIInFkWcaNL63B715fZ3ksKwgy7cZKSTaWgdLaeaAJP3nsM7y3brcwxZq17Hy+eT/OfORT9X00Zsf4mom6sayOsHqOEc6apr93r9vFLbYelwu/OnEQjh9SBsC4yjIrdliBUZTjsWU5sWvZUY7TPiulPUMoVrH40mdW4P7536nPg7XsaB99opYdNfVc0OsrxyBAOZ6NFTFM2zebz76GQMbr7ZDYIYgMQu0ikuOHg814ffWPeH75DsNYAhGpsuxk0o3FLrCsa+23r6/D6h01uPr5VZaWmA++2YOvfqiNjymbL9yJpp5bYR2zEyci27DsuCV43C5MG14RHd9gjmLLTlQY22q0GbOMWQVYqwHKGqGQ74uLiyXf78Wi76rx2OLNcTcW4xrSXiHR9ieKZUdbLRrgm4QqFpzos1TcWLKuNs/M8X1ixxnLiYgM7LdoltrWkNghCKLdwgocK93BLg3JZBClImYn1ann7DTY+imiRd6saaVV13OheLLxDKxu10owyRprmvZ4j0viLDtKxWSrLDU2licudqLjdM23dmXZDVBWxJx23nmMZedgU1B3PHtPfhuNP+2gjCOydinPja+zE7eahcLx1PPyIj9W/G4qRvQsjs3V/FlX1WY2bofEDkEQHQKrqrp8zE7i19G6VDIFu3Bq69CIjjHbxo7jvIJy8u6JoMUY7JTDdiw7itixWOFElh3l3K4FNiw7Dt1YZjE7zUwMTVPstdsl4Y7Th6Jnl1zMmXaY5XzsYCaa3LF/JBFZE7PDFRWUY+O40Z3plWYUQ6QIqN21zcL96cK4YhFBEG0OZWMlhyQZxzSYkZQbi1mXM+vGYuchPkZo2TERFlYVlIUxO1bRuTawdoUxwk5g2fG6XVw2lrLwWll22MrKIdWyExM7ttxYiogxP055RvqYHSUbK8KlgtfFiht63RIuOaYfLjmmn+Vc7OIX9DdTcAksO2yAcpApKqi15BhljvXrlo9N1Q3YeSCzYocsOwRBtFtkA4uG+Nj46+RidpIPUE4FYRvutLBAiJjNWZbNn2NbpZ6HwjL+99UurP+xVrif/+z01xTF7ADWcS186nlEHQsASu24sWLP19KNFTGw7KgVlMXtG9wJZlyZ4TOJrVEsO2EZnKhRhE2IKSqozb7yGsy1X6xm0Q8Hm5KbeJKQZYcgiA6BlRuLC3JNwvPCrmuJp56ntjeWUa8vcTaW8aStigomGrNjdcQnG/fiow17AQBb556qez6cGysi664ZjdmJnxOP2TG/rlHqOWDTjWUzZkcRRdpnHy/iF8H+Bn0Ab6JVks3we03ETux6bC0jn8elWsqC4YhqGdSJHY94rv1VsUOWHYLotJAXKzmcpJOnqhhgopadZJqPWs3DaBriOjvGSs8sZsdo/naegdUxi7/fq77esq9Rt1/72emKCrol+Dxx94zHboCyWcyOk2wsu+0itIHV7rglRZSt5KT/lV3MLDusG6uVc2PFLDuaLC0Wo5id/t2jYmdnhi07JHYIgmi3OBEwqXJj2XEfCc9LscvLKECZRVxB2SIby4FwshrPan4K7O5lW/br92vmoR3P7XJxlh2PXcuOoF2ES7Xs2HFjOWsEqrVIxbOfItjfqC+8507QsqMUBxRhatlhApTF7SIi6nPSuq2MsrH6dSsAELXspFrwO4HEDkEQHQLLmB1myUzmO5evs5PYeckyf30Vpv31E+HYXB8pYeq5mWXH2B1oNH87gs+J0Fu6WS92IlrLjiD1nM0ycsesF1buQtayE9FadlLoxjJKPWdTvUVurEQLByop7SL8HrMAZajzYWN22Eag6naN28qozk7fbnkAor242PT6dENihyAySCpiN4goVn81WqVkJ3IdJ5Yd9thkP/Wr/rPScE4sImFjVvE4HJEN45mcWI9E49rlh4PNqNUuihqrnDbV2+Pm6+x4DdxYWkOJqIKyIkAGlhWgS54XJXlew7kGwzIaAyHDdhTqcRGlgjL/cNWA4IiMAwI3VqKWHSWlXYQ29Xz6iGiH9/PH9mIClGUEY60wuDo7kYiaeq51W3kN5lro96K8KGol23kgc64sClAmCKJDYG3ZiZNc6rksfG15no0u5YnCC6n44Fa9sazGsrPdjpBx8rzX7KzBqLs/wK2nDFH7W/EByvp70DYCVUSC9jHnet1oZFK8RY1AlUW8KMeLpXNOwOa9DZj+8KcQcaCxFcPueN/ynhThoM2OU1xmBxpbhRWNE43ZyTex7Pg0Ymd07xLcf+5I5PncWLn9IIDo77XiovPo6uwYBCgbzNXrlvDcpePRJd+L7jZ7jrUFZNkhCKJDYLWgpqoYYKJurLZMU3dSZ8eqR5HRLJ0EQSdyjJb/m/8dMydeYGpFptslcZ3OFbeLNmY2R1NjhgtQlhXLDn+8mdvHCkVYhFTLjl6kAcDmvfqgbHa/U4wsOy5Jb5Hxe1zI93sgSVI8QFnWurGUbKx4N3R9nR3jooKDKwpRVpiTUUs2iR2CyCDkxEoO3lpjcSwb15KibCxHbqw27IPoJKjYSdaa1VhA6t1Y4jkxYwlidkSNQAG9m1gndth2EWFF7NgLvLVDTkzsGMX2uDRiRpsplagbS3uf7Hja+2HFnBqgHInHGUXdWEo2VtyNpbfsiOeaLa56EjsEQbRbuKKCDurs2KkNY3zN+OtMxexoMXoOdoSIFqNTjEWQtYpL5nkD+nR/UVaTX9QuQrPQ5mqylALCruf2LBZ2UESHMraRZUdh4qDu3L5EhQJ73tAeReprlyTpBBSbnSXqjeVl6uw8t3Q7Nu1tiM4vCRGYCUjsEATRbuGykKzWU9Yik4SVJdE6O1zjzsQvL8Q4nsb5jTpOPbdl2XE8DQ5tvJW4Eah1UcEcTdq1yI2ltbYkZdlRxI6SjaWJ2XFrxEwXJhg6GTHBCtO/nn94/HqahqkAH7DsYgKURXV2AOCF5Tui2zUWsExWE7cDiR2CyCTt64+jrMOJlSXi4Fi74zjqx8VVPLZ3zhNLNmPOa2st3W6GMTsJ9K0yDlA2ON5OgLKNY0w9NppMOmG7CLcgZkdr2TGL2TGw7Bi1QbCDErPTGo5AFrjftFYWNvPLqEifHdiPkLVmuV0Cy46H3w9EPy9RuwgWbep5lmsdEjsEQbRfjLp9i3DSR8vuNZ25scRjmPG3RZvw4hc7LUvtJ5MpZXcs45YUNiw7Nu7XLIPIyprmcbv4AGU1Zoc/ThvLojQClRlrkVYMJGNhYa0oRiKNpSQvXtsnmeuyz8uryVLTijnejRX9f0MgpKbCF+d6hcJLuy2TTXHtkFGx8/HHH+P0009HZWUlJEnCG2+8we2XJEn488ADD6jH9O3bV7f/vvvuS/OdEASRCZwID60rJFFki4XXiEQqLyt/XbdY1HExGi6RmB1DN1Yyqec2jtHG0xjNiY2zUdCmnhvF7BhlY7H3oLPsJBGzw1pELnv2S32dHeZaHpeEfJ++5UUisM+LvYZbknQxSKxlR3legVA0ELlHcQ4OKckVWna0KeyZrI5sh4zW2WlsbMSoUaNw6aWX4uyzz9bt3717N/f+vffew2WXXYZzzjmH23733XfjiiuuUN8XFha2zYQJIsWQFys5nDTl5Gq1pMiN5aiCMlefx+61oue0WgS9GFm4UmnZSSb13I7oErU4CEdkuF0SJ1RFhRK1Xc/dRgHKBtlY7O+DPmYnGbETP3cJ0/8LAO4/dyQnRPweF1f5OBk31olDy7FtfyOO6N2FE00y9CLKL3huChP6d4UkEEgA7wIEko/LamsyKnamTZuGadOmGe6vqKjg3r/55puYMmUK+vfvz20vLCzUHUsQRMfHidjh3VjJiJ1E3VjOz1M0QtAi9iaZ6sZ2zzGyzqSqzo6oxUFDSwjFeV7u/rSLLBD97PmYnehruwHKZpadRNO/RWMprLxtKroW+PH1rlp1m8/j4qxbybix8v1ufHrr8XBJ4IooyrKsG5d9JlpxeFT/rob30agpgphsxl1b025idvbs2YN33nkHl112mW7ffffdh65du2L06NF44IEHEArpK1ESBNHxSEX8jPNriq9vBbug2j1NOcesn5V2Tvz5zv/cNrrWW1/tEm7XiqNdNc2Yv76Kt2TZidkRFMKrD0TbRrCni+YXDEc0dXZiFZQlrRVD7MZi78FK3Pz1/MMxoX9XnZVIhCQBv4xVgebmETuXt+y4OetWMm4sZWxJknSWHTsBygq9SvN04z4+8wgc1b8UV0zkjQ7kxkoRzz77LAoLC3Xuruuuuw5HHHEESktL8fnnn2POnDnYvXs3HnzwQcOxAoEAAoF4h9m6uro2mzdBmJEtBbfaK5z7xuJYLnMrZb2x7J/n1I3GzjEosGYYzYklIcuOgRXpgfc3CLdrn+XE+z9CKCLjwZ+NwtlH9ASQuGWnvkX5w5V5FoL5hcKygRuLP07bF0rtWs6KHYt/k2cefgjOPPwQHP+nxdiyT1z5mOWWU4Zg1Y6DWLblgLpNESCsEPF7NW6sJNxnFcW56mtWwMiyPrvMzI2lPNPa5nivspOHVWBarJ8Wi0gYZRPtRuz861//wsyZM5GTk8Ntv+mmm9TXI0eOhM/nw5VXXom5c+fC7xf34Zg7dy7uuuuuNp0vQRBtjyjoeOeBJjz7+TZccmw/HFKSq9sPJBuzw8betJ0bi3PdWFl2DHYnErNjZUXSohVUyvtPNu5TxY6d+xXF7Cj9othLiJ5FKMJbdryqG0u8eCscbGrF3He/xbGHdlO32XVbaccyo6yQX7eUebHz87ld6N01LhgStZT8+qRBmMjcD2fZkWW4TSoo655X7DnuYzqya2OaFM45oid+ONCEo/p3xc//uTyhubcl7cKN9cknn2DDhg24/PLLLY8dP348QqEQtm3bZnjMnDlzUFtbq/7s3LkzhbMlCPuQYSc5RHE4v3hqOf756VZc9swK/ljuvMSvya61ibqx7GiQsEWcCotRgLJZnZ2u+T7hdithpcVIUDnNWhNlYzXELDvsPSnPgl3Eg4aWHXOxs/7HOjzx8Rb84qkv1PPsWlvtiB1l3krXb4W4ZSc+ht/rQmVxXBRZlRsQMbp3Ca45/lDuHtjXIstOjs/asnNE7xLLa7tdEm46aTCOHtjN8thM0C4sO0899RTGjBmDUaNGWR67Zs0auFwulJWVGR7j9/sNrT4EQbQfRAX+tu1vAgB8V1XPHZtomwctiaaeRwTCzPR4RnMorput+xpxyytfCcYWj2E2v1tOGYz31ldh8QY+S8hpIUJDscOOqetlJencUaI6O//4ZAv+8ckWnDayUt2mWJ5cLkm98XBEFqaea3WLlUCxcmFxYzlwM5UXxUWMJMWtI6zu8HvcnDARpdinAlbQFOd6hb2xFJTndeLQcvzjwiMxtLII7ZWMip2GhgZs2rRJfb9161asWbMGpaWl6N27N4BoPM3LL7+MP//5z7rzly5diuXLl2PKlCkoLCzE0qVLceONN+KCCy5Aly5d0nYfBEFkBl7AWBwLZ5YVI5wUMuTOc2gRYo9RFvhfv/wVVm4/qDs2kZidHK8bp42s1ImdZNxYbEd1sxipw3oUYe0Ptdw2kRvr8837AfBWDmV+HpeEVmabT9T13MAtY4STzCs7KenK5csYscNapFjLjjK34lwvFyNjxu9PG4p73v7G1rGAPvW8f/d8br822115ppIk4cSh5bavk41k1I315ZdfYvTo0Rg9ejSAaPzN6NGjcfvtt6vHzJs3D7IsY8aMGbrz/X4/5s2bh0mTJmHYsGH4wx/+gBtvvBFPPvlk2u6BIJKBvFjJwQcomwuIVAUoJ5yNxVmEnB2vuJaUqrb6OcWPZdd3s2wslyQJf/+cu7Gix7+x+kcMu+N9dTv7ZLQxUtoYFiCaoWSkNWqa4vfdGoqOxVohotlYehGhXby1AcpanGRAOXJjFcY9Cayg4iw7sRTwwRX268Rddmw/fPab420fH5FlLuamf7cCbr/OjZVEkHS2kVHLzuTJky3NubNmzcKsWbOE+4444ggsW7asLaZGEEQ7gA8WNj+Wz6JKTYCyk0Bn524svWXHaC027I1lIurcLkknBgAgGHL2bJRr3PDSGm67bPLZeN0SrjiuH/7xyVZ1m9/jgsftEtfRYV4rYowNtA1FZF1bBMA6ZkeLNnjXDNFYM8b1woJvqrGvIcBt786KHUls2VHmf/85I/HTJ5biiuP62ZoHG4RvhfbXTmfZcWgJa090nDshCKLz4cDK4sTl1RbjOK07w46tpJ5rFyN1TgZjmMXfuCTxeNqWBlYY9tJiXmtFodsl4XfTh+L5y8er23xuF7xGak7wLHjLDl8sL94ugh/GyvXkKGZHIHaOHdgdK353gm571/y42OFq+kj6Offtlo8vfnsCZk3U1+dJFq31c2gPPgbHKEC5I9AuApQJgiBEOBEbojT1xK6ZWOq542ws5iDVmmEgBoziiMzib1ySOPPIccyOgaBSLDtsk00FUZ0Zr1vfkVtBlIbPHhsKRzjhprzW3p+lZceBG8svEE5ul7h2VlFufKllA49ZSxJbV6et6m8pj/E304Zg+/4mTBrUndtvFKDcESCxQxBEu8VJ7ZpERUoy1+TPE49hBOsGUjKXjBZBI7eYWUaPS5KEbrFWh24s49Tz6P9Fu90x9w1rjfF53IaWF3aIICN2/B4XAqEIjuxbygU4ez3WAcpd833Yr4mBchKzI5qr0edjtF1k2WlLlOd41SSx1UhbQyfRVhmjehbjqx9qbaWspwsSOwRBtFt4a43FsSlyYyXcCNSh2BLV2THywhh5np75fJvh+G6XBFGIslM3VliWhWJL2SQSQ8rC7mazkTwuw35Qojo7bpeE92+YiHfW7caFE/qgMMeLR39+BGTIaiVi7VrNWipK8rw6sWNUME+EyOrhxA0GaDqSp0HsWJYZTxH/uPBI/PfLnThvbO/0XNAGHcdGRRDtEGoXkRxOgn5T5caSE7QQ8RYh6+PDggBlo8U0kfuRJHHAs1M3Vjgio4lpNqmgxIeI5qa4b1hrhs/jMuz0LUrDd7sk9O2Wj9lTBqIwxwsAmD6yB1eTxyxA+XzBQpxsNpaZYCnM0dsW2OOTsewMiWVw/WT0IabHWWUspoqyohxcc/yhXGB2piHLDkEQ7RYnfapSlo2VkgrKdtxY8ddcIT3RnBK4HaNqwU7dWKGwjP0N+pR4O5Ydzo3ldnHp49xYzOvNe6P9qOxYQrS3x6aen3BYGYYfUoy9DQFc9+Jq22Oq8xWIHe3nw867JM/L9PqKHc8cnoxl579XTcD6H2rVLuVGZHmvzjaFLDsEQbRb+C9vJ9lYmU49tz6et+xEXxtmYzloiKpgFLPTEtRbacyIyDL2NwZ025X5i56RsrBzjTA9LuMFXxT3Y8Mqqo/ZcaM03wefx4WeXfIwYUBX9ChmC/6Jl0TRtERp2WZ6pSRX355DSlHMTlGOF0cP7GbphuvEWocsOwSRSciJlRxO4me4CspJVOIXtaiwdR5zTTttJliREBCkW/Nzcr6MRcWOfry6FnvVexVCEbFlR5mzyNWn3IdbU2fGKEBZVOjQjiVEe39ul4Slc46HLMctM6y1x0gsuCRJ94ztxOyw74pzvaZzdRsIrVSSjMhv75DYIQii3eIk6LctemM5Sj136EaTBXEqRuuhMo21P9Sguq7F1nxckng8u60KFMIRWVjZWQkk/krTFgKIN/3Uxuw4ceU027BAaYeLZnDxbSm4NhMmYkdrFxFadkzcWMV55mLHKDg7U6QjXjqdkBuLIIh2C6sZrORDohYZ/TgJurEc19mJvw7aqLOzoaoeZzzymS7DyAijbKy6BMSO6JqBUBjb9zfion99odunBOu6NWLHSby+yJqkRRuTJDIc+QSVl/XjCM4TxeyY3MCQcvM2EGlJPXfwe2/k0muvkGWHIDIIJWMlh5OgY74RaDIxO+LXTs6z0y5ClI1lHLMDfLn9gP3JICoERMNpg2itCEdkoZUlEIrg0037hOcU+KNWDs6y43Y5WowbAtbz1OoH0fNjRYuR2LE6L36+8VyumNgfP9Y0Y+ph4oaa6RA7TkhLKnwaIbFDEES7xZG1htnvxCKjv2Z63Fhc1eCQeYByRJYdW6vcLnHMjlk/LRHBcETYz6o1FMGeOn3gMgAUxCw7bNVgo0ysZBDF7GjhxI5hUUD9NnGAsvE95HjduO+ckYb70xGz44RsE1/Jkl1PlyAIwgGstcZqsXdSgNCMhCsoMxe1E6Asqi1j3Ag0kQBl88XZLi3BMAIhsWVn+/5G4TkiN5aTgn520d6e6H7ZGB6jOjR2LTvJPM+si9khsUMQROroWF8o6cZJCwZWbNhxIxmPI76+5XkOU8/ZsdmqwUbHGq2zlx7TT7jdKPXcKS0hsWUnEIrg+z0NwnMK/THLDltBuA18uvqYHZHYiS+DRiJUNDVR5pgyvtImYca4XnanmnVuo45m2SE3FkEQ7RYn9WU4y06ae2Mt27IfN/33K0fnOYnZ+WLrAXyxVRyzY9TM0SVJCWltr1tS6/4AUSEm6sHV3BrC5mpxsLPixmJvpy0We1E2lhbWHWUkdsQWIWPLzgtXHIVN1Q0YVlmkO8aIbBMX2Sa+koUsOwRBtFucpJOzuw0adduCsybZEE176wO6jCQ7WsuoRYJTjMSOUcyOFSKLRr2gNk9ja1hYHweA2t4h1+vGYT2K0K9bPipLch3FHd104iDLY7T3J7pf1l1jFK8kLCoorKAc/X+O143hhxTbagdz+qhK5Pvclq0e0k22ia9kIcsOQWQQysZKDie9sZwca4aTFhWrdxzETx773HQuRrBCqtWigrIZIgtEdKzExouKHT5Gx2ltngK/YtmR8Pa1xwJwJuTmTBuCKw06d7PoxY758UaWne6Ffhxs4u8xFY1AAeDh8w9HKCIbFlTMFO4siyFKlux6ugRBEA5IuJpxqrKxLMb5z7IdCV8/LApQTuCvbUOx40osZke0KNc2O0tXV8QOEBU5Ti1WimXICq32sLqO0efy2MwjcETvEjx76Th1m52igvbmKGWd0AHaJoYqk5BlhyCIdkvijUATv6aToGg7YxgeIygqmIg4MYvZseNm0SJKEXdaiDDZeJAcrz1xoLPsWFzXyI01sKwQr/3yGG6bMEC5AwkEitkhCCJldKyvk/TjKGaHeX3fe9/h+z31CV2Tq6Bs1aLCIGyaHSMUjuDBBd9j+Zb9hsco2U6JaCsjq4HbIhvr4qP74pJj+toaz2k/rWTJ8bqtD4IgQNlCjDgJXE916nm20dEqKHesuyEIolPhJJ1bK4ZO+svHCV2TF1hWBxuPoVianl++Aw8v3IjznlzGHSNyYyVSDFHkbgGiLh7WssO6lgAgz+fGbdOH6s4TWXacVl02wu7d5doWO9ap5yxOCioKs7GydEWdOKg7AGD6yB62z+lolh1yYxFEBulAfwhmBKsWDP9eug0fbdiLx2YekVQ/LP6a1oHO97z9jbDQHoscq43zxTZxyjhrZahvCeGyZ1Zg4XfVjudrno0Vf5/jdaMlGFYXfKM6PNkQX+K36cayU1SQxU6xRwVxu4js/Af9yM9H46Pvqg1bVYjItiKHyUJihyCIdgtXQVmw//dvfg0gaj1JkdaxdGM1t4bx1KdbAQDHDOxqOE5YluGChH314pYK7NCBUCQhoQOYZWPxqecuKdqNXLHSaC0/CuwiL0nJNVVNFLtuLDtFBVmciB2R6MtWN1ZRjhdnHu4stT1b7yVRMi/RCYIgEsRusPDe+kAKLTvi1wphLh7H+KLKfPc1iMWOk4XXDMMAZRdv+XBJfFaUIhS0ax5bf6XAZ/33cu/SPHz+m+PRqzTXwazNyfHYEztarAwvTgLORWN1JIHQ0erskNghiAwiUYhyUtjNsGoJhpOqrWN8Tf2Ydq+jHLavodXyOslgFLMjsuywC5zyUvsbylo08vzWosPjllBZkouHzx+NLnle3G/SDNMuub7ExI5V9pkTgVmc68VR/Uu5bdnqxkqEjnQvAIkdgiDaMaweMBMHgVC4jSw7+kHZlHGztVU5ly3Ix95DMp3ZWQxjdjRiR9K+j8kcrbWCEzs2LDveWNTu6N5dsOr3J+JnY437RdkVeHZTz53iJEBZkiS8eMVRuIopbtiR9EGP4pxMTyGlkNghCKLdYjcbKxCMGKaBJ3NN0doYiohbJOjH0bdZYNsr2LEyFOVYiw3zOjvx95Kk6UIuxbezsNlYdrKi2EDXROr6iEjUjWWFU9ehpHmGHaFT+D8uPBLHDynDbafpM/HaMyR2CCKDsF+UqXJbdCbsxuy0tJVlR7A4hm261sIRGVW1Ldy2lta42LEz36cvGWt5jN9AGLhcvCVCJ3ZcSsyOsWXHjjvJ0wbZW3YDlJ2SSJwU+3Q6QlHBE4eW418Xj0W3An+mp5JSSOwQRJZAWsc5sgPLTorifTmBIxJY7IJpVqROlmVdo8wWJl3dzsJrx1Jit4KyNkBZvYbmPWupseNO8iZo7fjgxom4ceoglOTpW0MYZZglS0Jip407txOpgcQOQWQJyfRr6qzYraDcEgq3iRtLtDiy28zibiIyH98DRAOp7ZyrYCf7R1QEUDmXj9HhLRPKPrPO4VqrUb9u+brrOKnXonT+PqxHEQaVF+L6qYfqih0CqXcXnTCkDABwwVF9HJ/LJhl0AMNOh4Xq7BBEBmG/G0nqOIeL2TE5rrk1LDwgEpEdL5yWqec2LTsRWdYJmpYg68ayI3YsD7HtxtJadoxidnixw/+9/MpVE7D2x1r869Ot+GTjPgDOihBedmw/DK4oxOjeXdRt6bCW/O3no7F8ywEcbVIXyQjOskNqJ2shyw5BZAlk2HEO+8jMxEF9S0ho+QmE7AUTc9e0qKBs37Ij6yxDzaxlx8bU7Fh2zFLPudIHugBlsWWHfcsGKEsSUJrvw5TBZVxMjZN6LR63C5MHl6E4N+660l6/v8B6lCx5Pg+mDCkzFIZmsK5AcmNlLyR2CCJLIDeWc6wyoxTqWoJCy49VSwera4rEDCd2TARLJKIXS07dWHYMCW4DN5Jbm0mkS0WP/V9zHntMDhOg7HO71IWfjRNKNkCZ1Q8/HdMT7984ManxUg37fFKVbUakHnJjEUQGybYvx/U/1qKyJHWVbtsavs6O8XF1zSHhftZtZEV1fQuq6wKOKihburEixmLHnhvL+vfHyLUiSXzsiwSDNHHB6WeMqsSBxlYMqyxSt7EuLdaaZBQzZBf2HotzvVnRm4tof2T0t+bjjz/G6aefjsrKSkiShDfeeIPbf/HFF8fqGMR/TjnlFO6YAwcOYObMmSgqKkJJSQkuu+wyNDQ0pPEuCCI1ZNqys3L7QZz2t09x9H0LMzoPJ1hVM1ZoDobRKnBZObHsTH5gMU7726fYsjf+/SISM2yLCEs3lknMjp3MIDtiR3SIS1KKCPJjaSsqi64RkWU8PGM0/nP5eM6N5WNcQKzA8STZCpxvYZHUUG1CR2oR0ZHJqNhpbGzEqFGj8Oijjxoec8opp2D37t3qz4svvsjtnzlzJr7++mssWLAAb7/9Nj7++GPMmjWrradOECkn016sj7/fC8CZtSPTcF3PLY5lKxUr2L3XPXUtaGoN664prKBsU4DJsv4z59xYtlLPLQ8RxpGI4nG0dXYkZjsLOy1W7LCWHdb6kmz3bEkSWJuyiCycEiEgo26sadOmYdq0aabH+P1+VFRUCPd9++23mD9/PlasWIEjjzwSAPC3v/0Np556Kv70pz+hsrIy5XMmiLaCInacE7EIFmY52KTvQcWKCzOWbt5veX2FkJNsLFM3lvW87MTDiiwP8YKB8W2SNhvLJQ5QZp9zHpMW7jMQO96kLTvsHJMaiujEZL3zc/HixSgrK8PgwYNx9dVXY//++JfO0qVLUVJSogodAJg6dSpcLheWL19uOGYgEEBdXR33QxCZJtNurGxaSF5YvgO/f2O9pYDh6uxYWEJ+ONis22Y3G8tQ7AhOj5hkYx1aVqC+vvXVtbrWEs4DlK0/NHF37tj54N1WboEVRXs6O6t+XeOZUaxQ4gOUUxezk42Nc7NvRoSIrBY7p5xyCp577jksXLgQ//d//4clS5Zg2rRpCIejXwhVVVUoKyvjzvF4PCgtLUVVVZXhuHPnzkVxcbH606uXcWM6gkgXmXZjZdNC8uCC7/HvZduxsdo8/o5LA7cYsyEQ0m2za9nZtFc8D2vLDr/v8uP6qWnVy7YcwIJv9vDzYcSXHfFrL2ZHf4xbdWNptgvdWJqDmGn17BIPZt/DtL7gA5STzcbSxxFlEx2hH1ZnIKvFzvnnn48zzjgDI0aMwFlnnYW3334bK1aswOLFi5Mad86cOaitrVV/du7cmZoJE4RDuHUk02LH4Ds7Ez27lMBhkUBhscqMssJI7GzZ24CJ93+EeV/sAACEDHLIRdYXzrKjmZQ2KPhAI+9aa26Nz8fKUgUkvvgb1dAR1dnRx+zE58Uu9PXMZ8XF7CQpBrT9uwgiEbJa7Gjp378/unXrhk2bNgEAKioqUF1dzR0TCoVw4MABwzgfIBoHVFRUxP0QRKbJtBvLaE3KxLSUjKaWVnPLC9sCIhFRZuTG+s1r67DjQBN+89o6AMYuJXHXc2M3lluSTAOP+d5YhoepJJoJZBSPI6qgrP290D4KUWq518NkYyVp2eGtTaR2iMRoV2Lnhx9+wP79+9GjRw8AwIQJE1BTU4OVK1eqxyxatAiRSATjx4/P1DQJIiEyHaBsFP+RCRGmCIJmCzcTl42VQstOnSZzy0h4WFVQ1lpnXC6oWV2AXiwFgs7cWIlaOtSYHZd2u8CyoxEY2nmN6lmiG7+t6uxko8eIUs/bBxkVOw0NDVizZg3WrFkDANi6dSvWrFmDHTt2oKGhATfffDOWLVuGbdu2YeHChTjzzDMxcOBAnHzyyQCAww47DKeccgquuOIKfPHFF/jss89wzTXX4Pzzz6dMLKJdwH5PZsJdZAcns9q4px5rf6hJ+prBWLBLk4Vlx06ad//uxu0FjCw72po8Ri4lq0ag2jm5JImz/GjFFvveSuz898oJCS+0SjsHzosqa1xOiiAyDtkBAPzlvMMx/JAi/PX8w9VtvBsrdTE72ejHysIpEQIyKna+/PJLjB49GqNHjwYA3HTTTRg9ejRuv/12uN1urF27FmeccQYGDRqEyy67DGPGjMEnn3wCv9+vjvH8889jyJAhOOGEE3Dqqafi2GOPxZNPPpmpWyIIR/BduzM3DzOcaLAT//IxznjkM10sihMiEVm9ppVlh115lZfaxad/twIYYWTZ0YqghN1YgpgdlvoWPiap2WadnbeuOQbj+pUmLHZyY20e7MTsaG9dK8p7lebh7WuPw5mHH6JuS2WdHVHQNEE4JaN1diZPnmz61+z7779vOUZpaSleeOGFVE6LINIG1+4gw44so3XTrhuLDeLdWx9Aab4voXkEmRSm5hRYdkryvMLtgLFlR7vdyLIj+v7iemdp3ViaZ1zfwrvLeMuO8JKxccTZVHbJ93m4cYCoWHQJYna02BHlfM2dZIsKxl9no8soG11rhJ52FbNDEB2aDFt2kl1IWhmxk8xf86xASCRmR3tltsqvloChZYffbmTZCQlWfi71XLNb+4y12WaNAXturHimVGLPOS9m2dGezrqxlH1aEW7H3dqZ2kUMP6Q401MgbECNQAkig/C9nTI4ERi7COy6sdjg2mSq5rJiwcqywzcCFU8012csdlpsWnaMXEqi7WZFBbVWgIaYG8vrlhAMy9hbH7C8JhAXAAlbdvx6y472vZEby5ZlJ4VurGwPUD56QDc8PvMIDCwzdpcSmYfEDkFkEJl73b7dWKxlJ5m/wNlGmtaWHb1YlCSJW6HZnk1ajCw7dgOUg4I0LbN2EVpLTGNMzPUozsWOA03YU98CWZYhSZKFZUf5f3KWHX1RQf1ctbOw89vQVgHK2dgbCwCmjeiR6SkQFpAbiyAyCG+ZyNw8AOMaJnanFUhRA9GQg5gdO13P/R6XsBkmAARtmtMM3VhhZ5Ydt8FiXVGcAwCoaQpi8G3zsei7PaZFBY3q5Ngl7sZiYnZkGW5GmEjqdv5cW26slLaLSOp0ggBAYifrCUdkbN/fmOlpEG0Ea83JdFFBI6wWt1A4gu37G7k4l2TuxZllJ/7aKGbH53EZLphGlZG1GLmUWGEWCIWxdV8jZ9nRPgYjI0dpnk+1QLWGI7h+3hr13kQBvqrISVAI5KkByvx21rJjJKTsfLTsnJMNUBZliBGEU0jsZDn/N/87THpgMZZ8vzfTUyHagGyy7BhhNa1Z/16JSQ8sxuurf1S3JRN/FHYSs2OjgrLP7TJcJIMCy4zZnLSZXez5t7yyFlP+tBifbd5nOI6RG8btklBelKO+D4Vl1SqU49HHHBn1trJLvl9v2WHH5cfWBCjbsPX52syNldRQRCeGxE6Ws21f1Kqzg6w7HRIuZifDYsfIVSNbGD8WfRdt2fL4ks3qtmQsO2wcjCPLjsG1/V63sRvLoWWnNI9Pp2ctQ2+u2QUAeGftbsNxjESXJAFdmFT94lyv6sbye/Vf08ow2vEuProvJg/urjv+jtOHch3XFcuOFs6NlYRlJ5Wp564U1dkhodS5IbGT5cS/wDM6DaKNyKY6O0auGrvzspMZ5XQeicTsaG/DzLIjirkRoYyps+zEdjRaNCxVMLLEuF0SmpgxXFL8fvwiy44gZuemEwfhzjOG4ZlLxukExiXH9MOTFx6pvs83yFDjA5Sj/9d+lEN7WPcSTG2AMvs6ccVCWqdzQ2Iny5HVL3BSOx0T4/iOdGNcOC+BsZK4F9Y11GRh2dFWoBaJLL+Xj9kZ0D0fM8b1jl3L3LKjrK2qZSdfbNnZVN1gOo6C0WLtliTUMP249jYE1NifHIFlR9SRnL1H0fNn9xtZdlwW8THXHj8QN544SHguS0orKKfIjZWtmVxEeiCxk+Uo391k2emY8It1hi07hi0RnM8rmVthLTtWXc/Zucmy+N+Jz81nY9104mAc2acLAHE2FiuYlKBh5dkU5/JiJyJHReL3e+pN56kgSeJUeJdLwszxvdX3wbCMfQ3Rlhs5gqKIirHEKC17xrheAIDjDu0WP4fZn+cXW3Y8nNiJ/p99Qr86abBao8cMvhFocstMqkQKSZ3ODdXZyXKUL/NsbRLZGbjzra+xtyGAR2aMTvlfh7LB60xg7MZyTlIxO5EEY3ZkWXjdaDYWbx1QUqODgqKCbEFBxYWkWL2Kc/WtJ5Zt3Y+bX1lrOk8FlyRhyc1TsOT7atz66jpmO3D15AEYUlGEa19chWBYRlVtMwADsSMIUGYF3W3Th2Liod1x9MC42GF/dfMFlh1ZTp0VxethKygnm40Vf52UG4vUTqeGLDtZjlHQJZE+nvl8G95ZuxsbbP717gRZY5nIJIZiJyE3Fn+Stkif3XlYdT3XWsZE/078HrcuyNUbe8+mjouu6dNZdvRi578rdprOkcXtklBRnINTNUXo3C4Jfo8bpwyvwMCyQgDA7tqW2Pz1X9PxbCxxdeEcrxsnDatAAWOF4Sw7BjE73HNSKyg7/wVos0agybixyLbTqSGxk+Uo3/s2k0aIFMN+0dsNZnU0vsG1MoFhNlaSbqw31/yIYXfMx/tfV9k6l42jMepKLpqbLIuFmc/j0lgsJHUxFqWeN7XGA4XlWByQMq6oqejW/U0AgGumDMTInsWm81XWbW3MDCtEyov8AOId0T0CN5A4Zsd8MefFjtio70lRTRufSdVqp0hSauZEWqdzQ2Iny6EA5cyS7GMPhMJYs7PGMPiX3Z7pT9gwQDmRsZgHt3L7QQTDMtbsrLF1Lm/ZCQnFVn1LEF/vqtW1ixBbdvgAZUmKWxuC4QjqWoL4Zledup/NAIvIMjcfkWVHKQ9x9MCuXKyKCGXhdrskLmOKXcS75vu5c0RuICVmRzKI2RHBBSgbxOyIup4n8vmzzyHZf0MpC1BObhpEO4didtoJmf6rv7NiZO2wy7UvrMYH3+zBracMwdWTB+j2Z1WdHQPrYSLzYs9RrCdm7Q9YtF3DW8MRXfr19Ic/xY4DTehWEA8YliELA5T9HpfejRVbjENhGSc+uAR76gL475UTMK5fKefGCkdk7ndAJHZqY1lUvbrkWVo0WFHjdknqs2FdNVrrkciaIdpm5S1ixZAwZgcyLyySkAesGyvZX2tOqCYxDsXsdG7IspPlGNUOIdIDaylI5Mvyg2/2AACe+nSr+IAsysYyun4i82LPUdxSZl28WbTuwpbW6Pl1LUE889lWVNe3YMeBqOtIyVgClGws6wBlF+fGimBPXbTT+Pz1UTcbGxQdichgw3qKBGIHiIqVHsU5NsRO/DVbf4adXxeN2BEZi0RFEl0WgcDs8zfqBO8WWXYS+LVkx0n211oUR5QIFLPTuSHLTpYTTz0ntZMJ2MeezJel0TqUXZadVLqx4q+VWjQhm2InrAkabgqGUAwvbnl5LeZ/XcW1peCvKQurPfs9bl2Qq+rGYq6lFE9kxU5Y5i07lSXxlg45XhdaYs1PK4py4HG7TDusA3rLTnx7/JhiTZVmkbARrflWQoCdmyhAWZa1wcCpEQfdC/3WB5mQqnYRZNnp3JDYyXLIspNZUiUyjb5ouQDbDEftGImRxAKUWcuOs7gzbdCwEkMzPxbg/NUPtQbXNLPsxN9LUjymhLUiKaeymWPhiIwwc0zXfD8en3kE3C4Jt766VhU7vUpzY9cSW0zYayuwsTisyNBadsQuK3vbWLrk+/Doz49AjtdlWPtGlPmUqAv9uUvHYX9jAP265Sd0vnBOSfzBQVqnc0NiJ8tRvmcoZiczpEpkGn1JZ5Nlp60qKDt1Y2mPs6q1E7+mUeq5ps4OJC5AWQu7LaKx7LhdEqbF0sZ/98Z6dXtFrImnVYCy20DgsK6aEk3hwqGVRXhb029LHMdjemkAwPSRPUz3izqMJ/prOXGQvkdXIhhViXY+DsmdzgzF7GQ55MbKLG1v2RG/zgTGqefOx2Kfm2Ixsit2tALEqj9W/JoGFZQ9Lr0by6VPPVfmzF4/HOGzsdjF1su8UWJgnAQos9YVdlxtgPIhJbl47/rjcEhJbvz4BGJ27CDsep7h30vKxiJSAYmdLEdxbZAbKzNYdfy2i1F9ENZ1lWk3lnHqeXJ1dtJl2QFknQU0KmwkXVuFuBuLt+IAQDAkTmd3uyTOOsDWv1GyxaxjduKvOSsPM65W7LhdEg7rUcTFC4mwcmPZwSVyYyU9anJorXIEkQgkdrKcCFl2Mkqy2VhW52obWWaSVFp2+JidiOn4WrT9qmxbdiL6Z+j3uCBJEtjG2xLYOjv6mJ2AxrKkzF8rJtjKwP5Ys04ryw4nlgzcWF20AcpKAUGLhT7J5uKQNXPKFrePSIAlRHbcDpEhSOxkOcqiQVonM7S5G4t9nekKykaFDxNKPQeWb9mP6voWVVDYtuxo3Vgay44oOwlQ6uzw11AsOFpXiJp6zmVjRdH2y1LmrxUTXlcilh1xzA47vzyfmys4qIoOi8U6qerCgjmpMTsZ/r3kg8spQJlIDApQznKUrxm7BdmI1MI3mkx8HMOFKJssOylMPV/yfTX+8clWeN0ShvYoMh1fizYrTGvZMVq0RBWU/bEmmi7NIq6ICVHMlDZmyJZlJyZyrAKUjdxY2loyJXk+7K0PcMdZLdbaystOkWXZsNdWJhHGESVAtliqiMxAYifLUXtjkWknI7B/1SZj5TH6muXjYbLTspPIbX+0YS+AqFWk1WHquVbsaJuBRhdk/VgRpoeVgiI++LgPcb8pWRCgDMRT0bUBwHzMjj03louL+dFbURRKcr2M2InN2+CX6KHzDsd3VfU4ZmBX02vbgXNjIblsrFSRKjcWaZ3ODYmdbIfcWBmlrS072ZSNZSRGEnFjcNlYSlFBm41URQHKrGXTcNESWXY8ejcWJHBuIvV0pc6OZp6qZUcjdthsLMWCZB2zE3/NVlDWaq/S/HjcjmQRs3PW6ENMr+mElMXHpJBkA5QHlhVgU3UDThlWkcppEe0MEjtZDgUoZ5Zwiiw7Rt/R7IjZ7MZ68uPN2LinAfedM9IwZoaFFSeKpcZ+UUHestISDKOR6URutAhH6+zw2xTxwQcoS1y8DXu+6Ppq/yo7biwLscM+O7MO4/27F2D51gPcddMhPniXkd7VlwlYIZjIM3jxiqOw8Ns9OOPwytRNimh3kNjJcuKp5yR2MkGqupIbGiPYCsqZDlA2uLwsA3989zsAwJQhZTh1hHlhuuhY8cEUN1CiqedNrWHUt8TFjpGFSBiz49G7sVxS1ILhdknctRRR1qoLUDZwY7kEbizLmB1xgLJW7AwqL9Dta2uxIwNwu7PcspPApLoX+nH+uN6pnBLRDqFsrCxHSRbJ9F/9nRU+NTzxD8G4zo74dSawU2fnm111NseKvw5FlNRze/PQtYsIhtEQYMSOiQVKKxiVLClRzyePRrwoIkcXs2MrQDmWjeV10C7CLRY+ADCovFB9nWxKuROElp0M/2Zq460IIhFI7GQ5ytdMpv/q76xEUmR5sVdnJzsDlFnhsnVfI7fP6JmwY8VTz3kRsa8hgEZGxMTPjVlSYs+spTWM+pag+eRh7saSJL3FQtsfKhAKx+YrDlDWChLOsuNNxLIjrqAM8GJHeX5tXlBPNm5OmknYeaQivZ7onJDYyXKUxUSzThBpIsLF7CQ+jq0v6ayN2Ylv36IRO0bPhH1uogrK9S1BTLr/I/zsiaW6c5XFvTAnWklY68YyxDRAOb7NpYod/jMJxERNa4gfI+7G4i/nFcTsOKmzY1RUEAC6FcQDlBWhl5aYHWEj0La/rhmiORGEU0jsZDnUGyuzsIt5qmsdaa0imf6EjcobsCJl674Gw30sIrHDCvY9dQE0tobx7e463XNVxizwR0MKm4P2xM4H31Rh274mbpti2eGtMjE3lsYK0xqKYPmW/Vi94yC3/fVVP0bH0Lmx9EUFrVPPmfMNigoCUUvUbdMPw6RB3TH1sHLTMVOGJHb3ZRqJ3FhECqAA5SxHWTQoZiczcAHESYwjsuxotUWmBa2RcGHdOi3BCJpaQ8jzeUzP4QJ/Y5aaEKN2wpH473V9IITi3Hg/KOW4wpy42GkQuLv085Rx1X9WctvM3Fhal9MPB5tx3pPLdOMu/K4agEXquc1sLL63lrFlBwAuP64/Lj+uv/DcNkHWBnJnR52dbBRgRPuDLDtZDsXsZBbOspPimB3taJn+iI3uT+vWYbOV7FiD1K7nzKGs8KlpauXOVcRRUcyN1dwatt0fS4uozo7yyqNxY/1Y02w6li5mhzk/x3bMDjseG7NjvYinY5n3ZHnMDmkdIlEyKnY+/vhjnH766aisrIQkSXjjjTfUfcFgELfeeitGjBiB/Px8VFZW4sILL8SuXbu4Mfr27QtJkrif++67L8130naoMTuZXgk7KXyAcuLjCMVOtrmxDKw0rZqAXfYwYzeWYJvA2gMANU188LEijljLjv3O5zwiN5YiLLQBylZoBYmw67k3sTo7dqaSltRzQQXlTP9iiqxNBOGUjIqdxsZGjBo1Co8++qhuX1NTE1atWoXf//73WLVqFV577TVs2LABZ5xxhu7Yu+++G7t371Z/rr322nRMPy3EY3YyO4/OCh+gnNrUc+1o6Ra0L3+5E+c/uVS1rBi6sTR1Z9jjjOKYQoKI+pDA2gMAB7WWHSVmRxE7rWG0JCh2FBEiCawD2tRzK2y5sVJUZ0dEOpZ5l8Ddl+k/tCj1nEgFGY3ZmTZtGqZNmybcV1xcjAULFnDbHnnkEYwbNw47duxA797xIlGFhYWoqOiYpcCVrxnqjZUZ+NTwxMcRfUnrPtI0f8Q3v7IWAPDQhxtx2/TDbMXsALxFyqjmjZFlR5ZlhCMyd63aZo1lJ6yP2UnUjSWy7CgWC6eWHbPK0XYDlFlN4zXpjSU+t+2XeqPmpJmEsrGIVNCuYnZqa2ujHYFLSrjt9913H7p27YrRo0fjgQceQChkHswYCARQV1fH/WQryl9VFLOTGVJl2REtVNpibZkq3vbM59twwoNL0BISCwozN5aTflphWcbNr6zFuD8uxO7aeHzMwUaxZSeeeh5K3I3lFsTsGKSeW6EVJOwfIGqdHQep526X+LUR6VjneVEYJdPfPOxjJzcWkSjtJhurpaUFt956K2bMmIGioiJ1+3XXXYcjjjgCpaWl+PzzzzFnzhzs3r0bDz74oOFYc+fOxV133ZWOaSeN6saiOjsZgbN2JFVnR79Nl42Vwc94+/4mw33a9gnsIm8nG4vd9srKHwAAjyzapG6v0Vh2tKnngVAk8QBlr3E2lqjzuRlaQcLeo1pnx21eQZmvs+MwQLmtY3Zk2bFrLR1wzz07pkS0Q9qF2AkGg/jZz34GWZbx+OOPc/tuuukm9fXIkSPh8/lw5ZVXYu7cufD7/cLx5syZw51XV1eHXr16tc3kkyRCAcoZJXXZWNbf0tn6CWvbN7BxOk4ClNljN1bH6/VoA5QVt1m+LyocZBmos1NUUECO2i4ivk1xY1nF12jR1sJh70f5fJ3U2XFerTgNbixJP6dMW5VFmXQE4ZSsd2MpQmf79u1YsGABZ9URMX78eIRCIWzbts3wGL/fj6KiIu4nW6EA5cwic26sxMfRLmaRiIyXv9zJb0tgUZFlGa+v/gFf76pNfHIWaGN2IjYsOyKMjtWmnivH5fnjf4vVNVu3i9By4tBynDw8GssnCrzVpp5boa2gHBZY4hzV2XHoxmprZPCNQLNFWUhS9lmbiPZHVlt2FKGzceNGfPTRR+jatavlOWvWrIHL5UJZWVkaZtj2yBSzk1GSseywn5m2r9Erq37A79/8WnO88/mt3lmDG1/6CgCwde6pbRLEqnVjcannDiZtJHYOalPPY5akPF/cJaQNYrZiSEUh/nHhkep7lyDI1eOww6ZWkIh+H5yIFqfBwGlpF5H1RQUzOBGiXZNRsdPQ0IBNm+K++61bt2LNmjUoLS1Fjx49cO6552LVqlV4++23EQ6HUVVVBQAoLS2Fz+fD0qVLsXz5ckyZMgWFhYVYunQpbrzxRlxwwQXo0qVLpm4rpShfNOTGygzJNALlFnfNl/TKbXxLgtgVbI07f/1uLN28H78/bSgX3PvDwWb0Ks1zNEc76AOUrVPPRRgJI23MjpK27nW74HO70BqOOBY7WtEnWsR9niQDlJM0t7IxQ9mTes6+zg5lkY1zItofGRU7X375JaZMmaK+V+JoLrroItx555146623AACHH344d95HH32EyZMnw+/3Y968ebjzzjsRCATQr18/3HjjjVw8TnuH2kVklmSKCrJp2Xb+4Lf7GV/1n1UAgGGVxSgriselLd28v03Ejs6NxcbsOHgokYiMskI/qusD3HZdBeXY+F63BJ8nKnZqmvljrNA+b1GMq5Vlx+9xqc1BAUGAcpJ/gJj1xhKRjnVemDWY6aKCggwxgnBKRsXO5MmTTf9atvpL+ogjjsCyZfpeNh0JagSaWZKps8MFsGq+pkVp5k4/4lteXcvFiCzdsh8/G5v6QHszN1Yo7Myy4xIsV7oKyrEx3S4X/B4XGgLRnlxO0FoARG4sqzo7uT43L3Y0YxpZtT69dQoeWbQJ81bsFO5Xx+PcWKaHAtD/DrUFrJ7LFtc591mS2iESJOsDlDs7ytdNlnzvdDqs6uyYNahk//K3s5glUmeHFSI7DhinjyeD1rLDVVB2ErMTloULaF1LkBuzqTX6THO9bsuAXyO0lh2+zk70db7fPE1cyeRSxzBJPWfp2SUPo3qVWM7RqWXnqskDAABnHl5peWwiyDJv2ckWa7LIBUkQTiGxk+VQb6zMYhagfP/87zD8jvfx0YZq4bnhsLFlx+paiaAVJWY4+atdl3qeaDaWLAvvUZb5bKv9DVGXVdcCn1q/xilad4zIFVJelKM7rygnbuzO0fS50oqdHK+xWLLjtnQaoHx4rxKsvfMkPHTe4daDJwgrLDJV5FILldkhUgGJnSxHWVeSDYYkEsMsZuexxZsBAPf87xvhuWYxHaJdyboNtO4mM4zaPIgIhLTtIuKvHVl2IrLh8Up/rEAojPqYtaxbvl9tw+AUfcyO3rLTvZCvwzW6dwlmjIu3odGKGa0g+c20IRhcXog//GS44PrWyzLfYdzeMl6U423TthHFeV5MH9kDJw8rR/cCcZ2ydMO7IEnuEImR1annBNsuIsMT6aTIFm4swFg4sAI1HX8la7OmzHBiBdK5sdjeWE5idiKy4e+xkpF1IJZd5nFJKMr1mLqxSvK8ungfBa144IsKRmEtO9efcChuPHEQ/rZwo7rNrxE7WldTZUku3r9xoq3ri2CzsbKhzo7Coz8/ItNT4OC7nmdwIkS7JiHLTnNzM5qa4vEB27dvx0MPPYQPPvggZRMjolDqOfBjTTMeX7zZcfpxKmDXeaOPwI4I0lrmRGck+xk7EjAh+9dSWjwocG4sJ5Yd2diyUxsTLYoLqzTfB0mSTN1YXfJ8hvt0AcqCuI9yJpNNbRjKFNXL8Zi7scywE6PFW3ZsD91mZIvbSgsnVLPgORHtk4TEzplnnonnnnsOAFBTU4Px48fjz3/+M84880xdOwciOZSMj84sds59/HP83/zv8NvX1qX92nYagRpl5US4QF7ra9n5iM3cmU7cWMEkGnFx9+VgGFk2KywYFTn7G5V4nagQYS07LomPoynO9RpfzNSNFf1/eWHcsqNY8FgBoq2w7CQ41s6x2diHKhvhXVf0nIjESEjsrFq1CscddxwA4JVXXkF5eTm2b9+O5557Dg8//HBKJ9jZiVt20n/tf36yBbe/uT7jKai7a1sAAB9v3Jv2a8uamJ39DQH88vmV+Pj7+FyM3FjsdjvP0M5jNrPeaAOJEx3HikQrKAPGbq8a1bITrcHTNT9qtWEtO7leN7yMyaRLnrHY0WVjCUwnJcz5ShVns9o7Tlpp2XNjZVm7iCz9e0rUr4sgnJJQzE5TUxMKCwsBAB988AHOPvtsuFwuHHXUUdi+fXtKJ9jZUb6AMiE47n3nWwDAT0YfgtG9s6AidQa+jLXZWH9451u8u64K766rEh7DEjax7Ig+TjvWOzOR4siy48CNpSXRCsqAsUVJKSx4oDGeiQWAC1DO9bk5Qdcl34kbK/5a2cVaDJRK1F5GgGitUE7q3Niz7DiroNxZEQWXE4RTErLsDBw4EG+88QZ27tyJ999/HyeddBIAoLq6OqubarZH4qnnmZtDc2s4cxfPMLwbK9qSwewYFqf1aOx8xGbWG0cByilyYznJ6gKMrQdKgPI+JmYH4N1YOV43J/odxexYuIzqWmKWHcZ8o31ETqxYdqxAfCNQ20N3OlhjG1l2iERJ6J/Y7bffjl//+tfo27cvxo8fjwkTJgCIWnlGjx6d0gl2dpS1JKMxO1nyBWP2BPbUtbSJ9Utr2REFcRrFoYSY1VJn2RHdTZJurNZQxPYzSIUba299AOEkRBMQt6QobqQDjVE3VrdYzI7WjcXeXolJzI5Wz4hidgDguhMORY7XhRumDgIAnDqiB7rkeXHKsAqduHFS/sGOBSKR1PO24LenDgEA3H/uyIzNwQyuEWi2fBkR7Y6E3Fjnnnsujj32WOzevRujRo1St59wwgn4yU9+krLJEfFFMZOWnWz5gjFayJ9fvh2/e309rpzYH3NOPazNrilD/DkYByiLxzHCjqC1clWFIjLnijE8zkF8j5awLGPZlv04/8llKPAnV72ia74fVXUtqhtrv4VlhxUgJQ7cWFwFZeb3+aYTB+GaKQPV6xTnevHF76bC45Lwk8c+58ZwInbaU8zOrIkDcPHR/RKuVt3WGAlVgnBCwr/dFRUVGD16NFyMjXHcuHEYMmRISiZGRMlUzA57vWz5gjF6AnfFivo98fGWlF9T2/Vc9DkYByizlh1nbqzVOw7i6121+GhDNX6sibvOrNxGduN2nLi8tERkGUtiAdpm7TLsUFkSzYjaFbtH5V4riqPb2ZidwhwPd/+FJkJLV1RQ0BtLQbvIe90uSJKk+8yciB07bqlsitnJVqEDkNghUkNCf5Y1Njbivvvuw8KFC1FdXY2IxpS9ZUvqF53OSqYagbJf7Jn+IlYwfARt+GjYX+1IRNzuwDAlnWuroNkp8mLFttU2B3VWhW33TQdg7X6y654KOghm1iLLsmkmlBP6dsvHqh01+OFgM2RZxo+xmKheXaLd2/1eNvvKx1nRcn1m7RqsA5StSEbsOHZjUTCKIXy7CHpORGIkJHYuv/xyLFmyBL/4xS/Qo0cPipBvQzLlxmKvly0fr1HRs7YshqYNUBZZdgyLCoZ5q5DdaykZSSKsLDd2LTtOA4tZwhFnmV9m9C7NgyRFW1Js3tuotoro2SUXAOBjTCTFeV7OjZXvM/760n4nJRL3odWNTgKUndbZsdMItLPiNrHKEYRdEhI77733Ht555x0cc8wxqZ4PoUENUE6z2unMRQxZtH2gRE/FsF2ESUFC0RnKNrPvcyvLjV33lHLc8EOKcOJhFfjLh9/bOg+I3kuqxE6u140eRTnYVduCpVv2A4gGJyt9qXjLjpf7PPJMupab98ayNzftvzkn/wbtiJdsq6CcrYiqXxOEUxISO126dEFpaWmq50IIyFTXc9Zkny1fL0aPoC0fjfa5iz4Ho+uL6uz84Z1v0BAQp/Irn7XZ97lV4UArEfL9nnr8/o31GFZZDCAan+L1OPuEZVlGIImYHxa3S0LPLnnYVduCZZujYkex6gC8Zacklw9INrPsaBdF9q3dBVNryXFiDWuLruedFbN4K4KwS0JRaffccw9uv/12rj8W0TbEU8/Te132iz5b3JQZCNnRWWecCKtQhD83FI7gH59sxYtf7MC2/Y2645OtoBzdbz7Ife99h+VbD+Bfn20FAHhdLq4qscfGoptKN5bX7VLFjWLZYcUO24yzRBMnlGcWs6P5ZuMsOzbnprPsOPjw7fybYeeUzW6sX58UTcufNbF/Rq7Px+wQRGIkZNn585//jM2bN6O8vBx9+/aF18t/Ca1atSolk+vs2Om43VawX/RZ8z1saNlpy5gd/rUT0ck+Q1nmxU99iz6LyU4BSSs3lZUI0X6UXo/Epar7PS6ELIpIptKN5XZJ6FkaDUZWYpV6xd4r81Eo0RQRNBM7WrHBdVey+fuss+w4SNe3k0qeiLUpE8yeMhCnjaxEn6551ge3AVzZgCx+TkR2k5DYOeuss1I8DUIE+12b7hCarHRjGQYot+E1dZYd+1fTWnZYwSqqSq0cbpb1Y5VFZSWGBpQVYOF31er7qBsrLijy/B402hA7yRQlZPG4JHQv4EWMUlAQ4MWONgMs3zT13LiJp/0AZU02lqMAZetj2HnY6ZKeKSRJQt9u+Rm9fvx1xqZBtHMci51QKARJknDppZeiZ8+ebTEnIgb71Zp2y047ik9u05gdjXXGybUiWjcW874lqBcUyl5TsZNkzI7WOuHRuLEKczzYWx8wHSOVlh2P26Wr8VLABB7zlh1e7PhNasPoxAbrCrEpLLRurFSnnrOHZEMj0GyFz6QjiMRw/PeEx+PBAw88gFAouWJihDWpcGO1BMP474qdqIp1DrcLV0wvoSunnnTpvQONrfjvlzvRGAjxbqyIuF2EEZxlJ8Ivns0isRO7wZBJC4Zk6+xo9/s8EhegbFaoTyESSa4oIYvHJeksNOx7tgt5sSZAWZIk3Dh1EPoK3Cu6AGWD12Yk0y7CjnihLCN7sI8yW76LiPZHQsbT448/HkuWLEn1XAgN2niRRHh++Q7c8upanPXoZ47OC3MWjez4iknXLC761xe45ZW1uOOtr3Wiz8nnoG0EGray7KhlBozHNBIzStyNlcVFe77X7YKXyXgqyLEWO+EUx+xoW06wYqclFH9OWssOAFw/9VDcfeZw3XZTN5bdbCxtnZ0UZ2O1l5idTMNmY2XLdxHR/kgoZmfatGn4zW9+g3Xr1mHMmDHIz+f9uWeccUZKJtfZYa0Iif4jXxpL562qa0E4Its2l4vSpjNNur7o1v1YCwB4Z+1uDC4vVLdr426s0Ikd2fyZKp+3uWVHfP18vwc1TUFOzPzvq134Zncdbjl5MB76cCMGlRfqLDIel4uznhT6rSsjy7KMQKrcWALLDit+2Ngmr0EPBtHzKtSINlZL2JUV2t+3VPfGIjeWPdhnSVqHSJSExM4vf/lLAMCDDz6o2ydJEsJh8wBHwh5yCiw7bBrvt7vrMPyQYlvncZWDs0TtpHsWkqSvoOxkElrBaLVYKpcyj9kRi4x8X1TssGLm2hdXAwC65vvw14UbAQBH9C7hzvN5JPgYN5Yty04KU889bhcXowPw9XPs/L6KsqSKTMROonV2zjy80tZ5dq/Royj+b5O0jjFsNlZ2fBMR7ZGExI62FxbRNmir9yZCXUtQfb10834HYoeZR0JX7hhwz8GpZUfTRNRK7Mx97zucPKzCtHidkdhRLBkiEbKrJh6vtWpHDbdPZ9mxIXZ++/o6y2PsYmXZOaxHEf575QT0iDUGFSF6XkW5vIUqkQrK7Of1zCVjcezAbvZOhL3squI8L96+9lj4PS5KqTaBfZZU2Z1IlCxOeCRSYV2pbYqLnR0H7BeB1LpgOiu8ZcdZF66QxrJj52+EPy/43vSzNgoMVgSDaL/Z56eN2bEToJxK3MIAZd7SM65fKVd7R8tR/bvqtmnFTiKwn8PkwWXw2GllHsNukcDhhxTjUMZVSughNxaRChL6Zrv77rtN999+++0JTYbg4VPPExvjYFO8qaQT0cIF5mbJF0wm5iFrnoMjyw4jPLQxO4bnRCLmlp2QeJ9iDVHq8IRsZkt53M7dWKnE45Z0bR/M6ueIKM33Ye2dJ+GhBRvVytBFOclbdnJ9bsuaQ0ZIXKZV9sS9tUfcJHaIFJDQN9vrr7/OvQ8Gg9i6dSs8Hg8GDBhAYidFaK0KdthT14KapiAGV0T/Wqxpjlt2kskk6oxI0GfEOXkUbChJOGLtxgKiBfUSidkp0Fh22ABis8DulmBY48ZK3iLiBI/LpQvONaufY0RRjhe5vvh5RbnJx+z848Ijcf28Nbht+mGO58PeUr7Po3ZzJ5zDflzObKsEESchsbN69Wrdtrq6Olx88cX4yU9+kvSkiCiJxOyM/+NCAMCnt05Bzy55qGHcWE6ymfjUc9undSgkSdKl4DsSOxFWcNjL5gkEI7bEzhXH9cNxh3bHhf/6AkC8dYKSrcWmtptdtiEQ4lPPM+DG0mIWv+LzuNAaimBQeYFuHyvatJYdtlqx3eiY0b274ONbptg8mof991qQQ2InGdjfh1yvcYsQgjAjZTE7RUVFuOuuu/D73/8+VUN2eviigs7O/XpXHSIRGTUJurFSERzdEdAWdjR6FiIhyRphtHV2jKhrCZq6sRTLjdft4v7izYktAopFh7XsBELGrpjGQIjrjWUUoPyzI3vitJE9LOdvhJF+Ya9th9d/eTTOGFWJf1x4pOlYxboAZXYubR8M3MS4v5y65Qg9t00/DL+cPAD9u+tFLkHYIaX/Cmtra1FbW5vKITs1fG8sZ4JDloF6TQVgJ0VvwzJZdqzcWGwsRjAsc7EvAG/ZsVujp7Y5aMuy43W7UFkST11WrDPKftay0xw0/uAbA2E+QNlA7Nx/7ij8+uWvLOdvRI7HLawa7bS+zLDKYjw8Y7RwH/vYtAHKvBvL0SUTogvTtNROJ3nCnMuPy0zHdaLjkJDYefjhh7n3sixj9+7d+Pe//41p06alZGJEsgHKMpeJBSThxurEfnJt3BT73u2SEAnHCwH6NIZSbTaWmYg5dmA3fLppH+pagqaBzEpNGZ/HhQHdC/DwjNHoXuDHku/3AoinnrOWHVHTUYWGQIhrBFpgUlQwmTU7x+sSih1PCjtgstYUfVZZejtn9yrNw99mjEbXfB/ufvubNr8eQRDmJCR2/vKXv3DvXS4Xunfvjosuughz5sxJycSIxAKUWWqaW7n3iWZjdeaySnydHf59NNA1uiEYkgGf5lxNvI+Ze+rGEwdFxU5ziLMIaYm7saIL9hmjooXulm7eF52HwLIjak3hc7vQGo7gvLG94HWZu7F8McuPyAoztm8XrNh20HC+ClE3W1C3PZWVg5tb43ExLs24mTCunD7KfhFCgiDaloT+rNq6dSv3s3nzZixbtgx//OMfUVhov2bExx9/jNNPPx2VlZWQJAlvvPEGt1+WZdx+++3o0aMHcnNzMXXqVGzcuJE75sCBA5g5cyaKiopQUlKCyy67DA0NDYncVtYhaxZaJ5YZWQYOaiw7lI3lEEmbei5z79msnqBGoKzcfgAPL9qkvo9YpK0Xx7KH6lqCworAAPD66h/w2qofAehbJyidwxXLTgvjuhJZVP592Ti89sujcd6RvTi7nTYNPHqt6H2KLCKP/PwIPDbzCKPbUjHKsHIas2NGk4kFi4r2EUTnJiGxc+mll6K+vl63vbGxEZdeeqntcRobGzFq1Cg8+uijwv33338/Hn74Yfz973/H8uXLkZ+fj5NPPhktLfGKsDNnzsTXX3+NBQsW4O2338bHH3+MWbNmOb+pLEQrbpxoDhn8X7qAvvy9Gbo2CZ0U7XNgHwXr3mMFiizLuPedb3XjmLmxlOyhumZxgHJ1fQtufCkeM6MVO8r7eOo5E7MjEAFFuV4c0bsLXC4J3Qr86NM1D/275YstOzGhIrKOFPg9OLJPF8P7UsgxyKJJpWXHVOyk7CrOufOMYQCA644fmMFZEETnJiGx8+yzz6K5uVm3vbm5Gc8995ztcaZNm4Z7771XmK4uyzIeeugh3HbbbTjzzDMxcuRIPPfcc9i1a5dqAfr2228xf/58/POf/8T48eNx7LHH4m9/+xvmzZuHXbt2JXJrWYV2yXNqYdGumU4sQ7yhonOqHX2Asmzo3mPr36zcfhCrY20ZXrziKADWqedKQG1EjgoeLeP+sJB773Ng2RG5sVix5HZJ+PCmSfjgxok69w8AdC/0R48TWEd8Nlsd+A3EjhKzk4qUYrP6PCkMDXLMUf274rt7TsFNJw3O3CQIopPj6Cugrq4OtbW1kGUZ9fX1qKurU38OHjyId999F2VlZSmZ2NatW1FVVYWpU6eq24qLizF+/HgsXboUALB06VKUlJTgyCPjaahTp06Fy+XC8uXLUzKPTBEIhfHht3u4bVYWFqtqv05ib6w6dHcWdJYdg5R8Vuz8cDD6h8DRA7piSEXcrWvU6gGILtSKgDnQ1Gp4nALb8wyIiwXFisNZdgxidli8bpewHcLInsV49OdRN5VI1Hhckq14GCMh4om5sf5z+XgMPyTaBytRbj5lMEb1KsGDPxul2ydl1LZjbNkiCCI9OApQLikpgSRJkCQJgwYN0u2XJAl33XVXSiZWVVUFACgvL+e2l5eXq/uqqqp04srj8aC0tFQ9RkQgEEAgEFDf19XVpWTOqeS+977D059t47ZZWXa4GB/IOpHiKECZYnYAaF2HvGUnzImd+GvFuuL3uLi4HqNYHCD6b6co14N9Da042GgtdrRuLKWWS0OseF3AImbHYzNW5q1rjlVfGxUAtFOR2NCNFTt3TJ8uePva42zNyYgexbl4c/Yxwn0UskMQnRtHYuejjz6CLMs4/vjj8eqrr6K0tFTd5/P50KdPH1RWZn8Gwty5c1MmytqKF5bv0G2zEh3amBxtQ8lEA5Q7sdbRua20QeMKrGVHseD4PC5IjCax6ldVlOuNip0mvRuL5cSh5ThnTE9um1L5uDEWp9ViEbOjFUt2MLLg2BE7RpaddIkQClAmiM6NI7EzadIkAFEXU+/evdv0C6SiogIAsGfPHvToEa/cumfPHhx++OHqMdXV1dx5oVAIBw4cUM8XMWfOHNx0003q+7q6OvTq1SuFs28brMSKtnmnzo3lpM5OkmnvHQFtu4iIJhuLhQ0qZgv/8Rlb5s9RqQ1TY+HG+uv5hyPPoHlmYyDmxgqyFZT1IkvrxrKDkaixEw/DWnaKcjyoawnptrclJHUIonOTUNhenz598Omnn+KCCy7A0UcfjR9/jKbD/vvf/8ann36akon169cPFRUVWLgwHphZV1eH5cuXY8KEqF9/woQJqKmpwcqVK9VjFi1ahEgkgvHjxxuO7ff7UVRUxP1kG6J1xUp0sDE5MvTiyFm7CLLsSJI2QNlYcHKWnVDcssNaQ6wsO4q1RSROWETBvPn+6LbGmBtLFJTMXctjvPwbZUiJgpcBa8uOJIGr5VPg92DerKPw0qyj0iZ27Db/JAiiY5KQ2Hn11Vdx8sknIzc3F6tWrVLjX2pra/HHP/7R9jgNDQ1Ys2YN1qxZAyBqMVqzZg127NgBSZJwww034N5778Vbb72FdevW4cILL0RlZSXOOussAMBhhx2GU045BVdccQW++OILfPbZZ7jmmmtw/vnntwt3mhmigErZIsDYypLjzI1lPE5nQldnxyAzjRU7ymuf1rJjIXYUkREwae8AiF0ySn0cVeyY9MMCzN1YhmInQTeW1+3ihJIkSTiqf1eM79/V9LxUMrQy+/6gIQgifSQkdu699178/e9/xz/+8Q94vfHy8scccwxWrVple5wvv/wSo0ePxujR0V43N910E0aPHo3bb78dAHDLLbfg2muvxaxZszB27Fg0NDRg/vz5yMnJUcd4/vnnMWTIEJxwwgk49dRTceyxx+LJJ59M5LayHkvLjkkBPGWbXag3lpJ6rm0XIT725/9Yjh9rollYvGWHFTvmD1IRIFZCRYTqxmoNIxKRLQWTWb8mo32i1HPAOu7G65K4czORBl6a78OyOSfgqztOSv/FCYLIOAm1i9iwYQMmTpyo215cXIyamhrb40yePNl0AZYkCXfffTfuvvtuw2NKS0vxwgsv2L5meyFpN5asb/xpp+t2fCyK2QE07SLU/4h5aMH3eOCno9AaEzXRmJ34fis3ll3LjogCphdUUzBsKZjM4u2MLDtG57CCzu2SdL9nXg9v2cmUS6miOMf6IIIgOiQJ/Y1VUVGBTZs26bZ/+umn6N+futO2FU4ClO28N4OysaJo6+yYPcPXV/+ImqbWJCw7MbGTgGUnxxsXVo2BUEKCScHYjWXt3hKd6nG5wHrNKH6GIIh0k5DYueKKK3D99ddj+fLlkCQJu3btwvPPP49f/epXuPrqq1M9RyKGlRuKc2NB78ZyErOTbBPSdJGMq84KSZJ0RQRFo08e3B1ANCNrb32Ay8Zi1/W3vjKv6q1adiwClI3mytbaaUlgDAVDN5bm2+Kh8w4HwIsXkZDxuXk3FmkdgiDSTUJurN/85jeIRCI44YQT0NTUhIkTJ8Lv9+Pmm2/G5Zdfnuo5dkpE64GVWGHjbMKR+PEel4RQxDhtWgQvnLIXfcYZkMLekro4KJEr8KmLxuK4/1uEXbUtaGoNc0UFo0U4o9axdT/Wml5LqWBslkll1oeqwO9BfUsIjYGQZTaWGWP7luK99VW62jisG+vKif1x1uhDYtvjx4jEjsedHW4sgiA6LwlZdiRJwu9+9zscOHAA69evx7Jly7B3714UFxejX79+qZ5jp0QUH+GkgnIkEl+YFYtBR8zGCml6YDiJS7JC2xvLqAKySwJyfNEU6qbWMGPZkWL77S3uHhuf0yM/N+4wzlp2ErEOKcw9ewRmTxmAd6/nKxqz7i23JrtKQejG0lh2Utj7kyAIwhaOxE4gEMCcOXNw5JFH4phjjsG7776LoUOH4uuvv8bgwYPx17/+FTfeeGNbzbXT4yQbK8w0rVQWUSdCoL30xtLeU6qFmVH/KwVJii72eTGx0xIMI8C4sQD7i7vHIk3pphMHmQbZsoUFk7HslOT5cPPJQzCgewG3nb0PI1eXqBaPz+3ixRGV+CMIIs04cmPdfvvteOKJJzB16lR8/vnn+OlPf4pLLrkEy5Ytw5///Gf89Kc/hdtNDe/aCqt1nF34wxFZPT7qHgk77Hpu0BchywhpxE6ylh32GUXdT/H32msBcatNnjf6T6mpNYwgE6AcHUeCHWegWTo4YBw4rFDAFBYMJCF2jOCzrsTCTDRHj1vS1NlJ+dQIgiBMcSR2Xn75ZTz33HM444wzsH79eowcORKhUAhfffUV9Z5JMaKnabWQa4NpFauE4k5JPEDZ/nnpRtv/S9sfTKE1FFHFh+l42hggxpjTKnANKe6ZXNWNFVJ7YymWHaP6NLqxLIKNrIZRCgs2BELC5p/Jwoodo0aiIped1+3SuLHou4IgiPTiyI31ww8/YMyYMQCA4cOHw+/348YbbySh0xYkUGdHa9lRFv54zE5iqefZHbOjcWMJlNk3u+ow6Lb38Md3v7UcTysowzbcWABUN1ZzMB6zowT42nVjea0sOxb/ztRmoIEQ6mO9p1IJOz07VZaV116XJkA5A0UFCYLo3Dj62gmHw/D5fOp7j8eDgoICkzOIVOKkzg7nxoqtLo6KCrYTy45OnAgm++cPNgAAnvx4i8PxJM6NJaqTo1gplH5Vza1hBEPxooLsMVYYuYbi+83HyWfETkMbiB32+kYuN/YPH78n+kz0Acr0xxFBEOnFkRtLlmVcfPHF8Pv9AICWlhZcddVVyM/P54577bXXUjfDTopoObCus8O+llUrh+JycGKgCXPVmDOndqyurYvZSXKu2vPZ4UWWHUUA5DLZWAGmN1Z0DHtz8lq4saxEgiJ26gMhNLSmXuxINgQLq4Hy/W40B8Pwe/iigmQJJggi3TgSOxdddBH3/oILLkjpZAhznFl2+Do72v3W18pMBeWPNlQDMjBlSJnw2pGIzLlEwhprSySBjGtZlvHqqh8xqLwAfUrjwj3a9TwBN1Ystscbc2MFbZrGrCw3VvuVmKTapmCbfGZ2YnZYC87Uw8pRHwjhvCN7cTWGKPWcIIh040jsPP300201D8IGTlLP2QBlxY3lSOxkIGanuTWMS55eAQBYf9fJKPB7dNcOyzJcjN1La4lJxLKzdPN+/PrlrwAAK2+byu1jdUqrQOyobiyfko0VD1BWLDtWPbEUPCadyKPXsjg/dkBNc1C4f0D3fGze22hrLiLY6dnpn1VW6Md954wEAHyzu07dTm4sgiDSTUIVlIm2J5GigqxVIxSOi52EigpmIGaHzSBqbg3HxA5/jE78aEw5ogBlKzbvbYiPx963puq0EovDojxbxbLzn2U71H0+j7PnbpV6LqphI5rLwaZW4f5fnTQYPx5sxgmHldmbkAb2d9K4pQRr/YmrI65dREJXJwiCSBwSO1mK6I9fK6OFUVHBeOp5YpYdcUeo1MMKC+WaumamGiOJnTo7VrNnF2Uuo415hoDYjaWs7UqAMovPYc0pI9eQglU2lmrZaRJbdgr8HlwxMfFGvez1jYKpucKDzP1QuwiCIDIJJYG2Ixy5sSJyPGbHYaAswFs4lJffVdXh+D8vxv8sGlomCitcFNGhnbLWTaVt4cDubw1FcO7jn2PRd9Wm1/UaiZ2IzNfZEcbs8AHK3LgeZ4t6spYd5XOuiVl2fBq3mNX4VrD6xrCCMiNkfJxlJ34MaR2CININiZ12hHWAcvw1a5VQ3VgOgne53lixgX/98lfYsrcR17642v5ADmAtJ4qI0butzN+zFqnFG6rx5faDltdls6DYwoFRwWhu2VGsHXkCsaMVG1ZYtYuwa9k5GLPsdMn38vsdzkcLX0HZul0EK4jcZNkhCCKDkNjJUkTLgZOigpEIk3ruUlLPE8zGiv2/JZh4c0k7sHVsFGGhd2OZBySz71tsNsNkLTtNrfG4obAsc5YlUSNQZQ0XiR2vU7Fj5cZymK3VJc/Hvbca3wqXnZgdLmMrfv9UVJAgiExCMTvtCKvgW1bMhCPxSBtlEXSSqSTKxnJqqXAKm7WkuLS0t6wTNzrLDrvPnthhRUJDIF6fJhLhxZaoN5bixsoRxOz4bbSnMJqHCCuDiLZOj07sJOvGsmHZYefIzoeKChIEkUlI7GQp4mws83O0wbUKXjVmx/71RdlYdnpLJQMbE6Nadiy6mmutLbzbyd4NsyKxkRE7oUjE0poWz8bS/1NyatnxJllBWRs0XJqvFTvJurGYsWz0xmKvxzcCJbFDEER6IYNylpKIG4uroMy1i0jAjcVmYymWnTYWO6xwMYrZiUSA+eur8OrKHwCYx/DYbY/BhuJwlh0ZsNJLZm4sp8/LUszYjNlR0MfsJBugbCMbi9ns9bAByqxlJ6lpEARBOIYsO+0IK7HDubFkWVWyngS6nouysZy6ZZwSiggsO5o5B8MRXD9vNVrDEUwdWs6dA/DztlvMjx2jMcB3C7caQ9sbi8XIsuPzuIQd1K3EiHU2Fr+/tA3dWHaysbwGAcqkdQiCSDdk2WlHWBlmwlzMTtyy4U6gESiXjZWmmJ3WkN4FpbVG1TYHEQhFIMtAfUvQNIDZrhuLfS6sGwsQByWzKAJEFLNj1OvK6DmmKhtLoUQjdpy61XTXZ0437o1lI0CZ3FgEQaQZEjtZimg9cOrGUt4rf2E7qbMjZyBmh7WwKK+1+uxAY7w6cEswrK+zw5ygtfoYwZ7ToBE7QYsxlDW8ONer22cUm2IkgpLPxuI/n6JcL/eZWZ1vBVdB2ag3lkt8DFdBmcQOQRBphsROO8JRI1A53uogsa7n+mrG7MKZSFsGK+zE7LB9n5pbI/qYHYvsKRHsGE2tDi07sYXb53Fh2ZwTMKF/V8vrGVlYtJaZv55/OPp0zVPfW2kErQDxuiX0LMk13O8UW3V22GwsFyu0xMcQBEGkAxI7WYsoG8vCsqOts6MWFUxNBWXW/cL2sTIjGI5gd22zrWOF2VhascP0fWoOhnWCRtsfzA4hzrLD35eokCALKwAqinM4cWKEkYVMW/SvX7d8zhVlZZnRiiWf24VKRuxYZXtZ4XYYs8O1i6DUc4IgMgiJnXaEVTYVu+6HIrIad6MsTE5idrTCCeAXY7b4nhkz/7kcE+YuwkoblYxDXFFBJWaHP+ZgI2PZCYZTbtnRxuxYxf1o9YModkeLXcuOS5I4K4hVzI5WDHncLlQU58T3J23ZMb5W/BgmQNktdqFRUUGCININfe20I6xCUFLqxmLjf2KvWbHVYtOy88XWAwCA55dvtzyWaxcREVt22I7eza16scOKNDvZWGt21qhzBAQByhYPXStARD2ytBjG7OjEisRbRCwtO/w/Z69bQkVRXOwka9nhW0HYSD03aARKMTsEQaQbSj3PUhIKUNa6sVzR994EGoHy7SKir0NcbIs9saMQsNFqIsi5scQVlFmx0xIM61PPmRNE6d0sTa0hnPXoZ9w2bYCylStMu3AfWlZgejxgYtnRiCCPS7JlTTE636e17KShgvKA7gX4bNP+6HzYooLkxiIIIoOQZSdLERcV5N8faGzFH975Bhv31Ov2h5lsLHcC2Vh8UcH4mAraQF4r3lm3G//8ZIvpMSGBVUYfs8O7sbSChnVjBSzEzubqRt02rYizjtnh3591+CG47oRD8e/LxhmeYxizo7GWRN1Y9ovx6S1DLvRgxI6RRckuXAVlzbVemnUUrpkyEBdO6CO8HpeNldQsCIIgnENiJ0uxY9m59dW1+McnW3Hqw5/o9kdkWV34ParYsX99rqlobBx2W7NDyw4A3PvOt9i2Ty8wFDjLTkRcZ6dG48bSChpWpAVC5nPctLdet03vxtI/NKNu3kDUXXPTiYNw3KHdDa87ulcX4XZdzI3L5cgioj3f65YwrLJYfZ+s+8hlct/j+3fFr08eDJ877sbj6+ww45DaIQgizZAbqx2hFTurd0SDfoOCNO1wJB6zwy5MkYhsGfuhHUskdpy6sRTqWoKG+7iu5yFxnZ2DGsuOFivLjizLeOurXXhh+Q70LtVnTmndWKKg7pI8L/Y1REVXIgLiiD4lmDR4HC761xfcdq0byu2WOJFg5YbSuse8MTfWy1dNEFZ4dopRphULNQIlCCIbIbHTjtCuu7q0ay5AOR7QzC6CEVmGy4YjISxwY7HxMXZTz83G1eI0QLklGNaJDXZ8UZxQRAaun7cGALCcCUxW0Fp2RJTk+VSxk4iVwuOSMGlQd/Ttmodt+5uY7foA4+QsO9HxxvYtdT5J0fiOu56Ls7EoQJkgiHRDYidLkQSCROvSCeuqB8dfs3V2WLeLXVeWKBsrWTcWoO89xRISBShr9Ep9S1yMNLeGdbVpIpxlR2D5sXgAjTbuq0tevFpyIkG/imjRLvraOJiiHC93jNM6O8nG6JhfS+wB56osc+nm9mOPCIIgUg2JnXaE1sphatkRBCiLxjCCFVbK61ASAcoKWjcRS1BTQXlDVb3pdZqDYfi0ApARRy1Cy05ylZ/dLgkF/vg/m0RcMsrnoT2VdQ15XBL8HhdYvWKdjaV3Y6USJSsPMK75w8ZMsfMhNxZBEJkk6wOU+/btC0mSdD+zZ88GAEyePFm376qrrsrwrJNHGKCsWbu1Vgpt13OxZcd5oT1hNlaCbiwzNxHrxlr43R6c/NDHOPfvSw2Pbw46D1B2UlhRRFGOJ2mXjGLl0C76rLWkMMcDKclsrJSLHebRGRUoZJ8vF7NDRQUJgsggWf+1s2LFCuzevVv9WbBgAQDgpz/9qXrMFVdcwR1z//33Z2q6bYpWqIRNrBqcG4uL2bF3LXbRenf9bqzacTA1biwTSw1rOVr7Q63lWC0JpJ5rn5lTinI1riUbWudfFx+J0b1L1PeKKNGeylp28mPWIympmJ3UWlDYJ2fULiLEiR1xnR2K2SEIIt1kvRure3c+hfe+++7DgAEDMGnSJHVbXl4eKioq0j21tKNdp3XVg3WWnehrdtGza9lhj6tvCeHsxz7HuH6l3LZEMHdj2etSrtDcGtZ1+uYClAViJ9kGpkU5XscumeOHlGN0ry4YfU9UqCvxWDo3FiMg8mKVmJ0UFdRWSPamuEs9azk0mktRTvwrxShFn6QOQRDpJustOyytra34z3/+g0svvZT76/D5559Ht27dMHz4cMyZMwdNTU0mowCBQAB1dXXcT7YhLipovlCzi1GESz2Pf8yyTT0hcvew2+w299Ri141lh2hRQd7CpDyjfy/bjk3VDYJrJGvZ8XBuGLtWCtZqo1iXtEHorAVOSRV3lI2l7XqeYn8R+ythFLNTVpSDv5w3Ck/8YowmuDp+DMXsEASRbrLessPyxhtvoKamBhdffLG67ec//zn69OmDyspKrF27Frfeeis2bNiA1157zXCcuXPn4q677krDjBNHZICwMkqwYiTaCDTxmB3RtVgXxc4DiYods2wsZ0KkORhBjlccs/P7N9YLz0kksDrP51brChXnejVtE+yNoU3/B8wtO0pDUSd1dto6G4sV02a1mn4yuqdum5PYI4IgiFTTrsTOU089hWnTpqGyslLdNmvWLPX1iBEj0KNHD5xwwgnYvHkzBgwYIBxnzpw5uOmmm9T3dXV16NWrV9tNPAFEosSyN5auXYS+qKDdmBXRtYKMW+iHg+bWMyOM3FiPLNqIeSt2OhqrpTWMgKZYXlg2bwCaiPutS54PTa1RcVeU4+UKKtq1UnBiJ/ZB6QOU4+9zfQlYdjQqItleWFqSsYlRnR2CIDJJu3Fjbd++HR9++CEuv/xy0+PGjx8PANi0aZPhMX6/H0VFRdxPtiGyrGjr7OjP4ases6nnylqTSDaWAltIsK4lhNpm42rIRojcWA2BEP70wfeOx2oOhtEaEzZKjEskIpsWPDSLGRpnUHyva4FPfV2U6+Uzi2wu3Hz6f/T/2lPZY3I8ArFj8a9Va9lJtagYVhn9d1LJ9NuyCzUCJQgik7Qby87TTz+NsrIyTJ8+3fS4NWvWAAB69OiRhlm1HSJRYpU2bdQuwiVFF5iILOuCnI0Qih1NBtYPB5tQnFusO06dj2AMrdj48wcb8LdFxsJURGGOB/UtoVjqeXROiqspLFuIHRPLzknDyvHFNn1V5S55jNjJ8WBfQ0B9b6f1hhblc8r38//8WHGiWHZYXWAUJyM6vy3I83nwzd0nJ5TSzgvEVM6KIAjCmnZh2YlEInj66adx0UUXweOJLxCbN2/GPffcg5UrV2Lbtm146623cOGFF2LixIkYOXJkBmecPGI3ltU5/GtFsLD1WoTjRmQs37Kf61slOk4b7/LDQfO4HZHLrDEQwqodB7E/JhicCh0AKC+KWhZaWsNqSwglxiUckdHSauzGMrPs+DwuvDTrKAwqL+C2l+bzlp1k408UEfh/54zEoWUF+Mt5o3THKPfD1bbJApWQ5/MkL3ay4D4IguhctAux8+GHH2LHjh249NJLue0+nw8ffvghTjrpJAwZMgS/+tWvcM455+B///tfhmaaOkRWESsXFGuNYSsouyRJtRCILDb//XInzntyGX7GFPATCSulInFFTGz8aCV2BIOs2lGDsx/7HMf83yLTc80oL/IDMHZjNQWNBY2Z2HFJEsb374oPbpyEkT3jFivWslOc6zz1XEtRbrTdRL9u+Vhw0yRhQK+ocWd7FgnsYyIvFkEQ6aZduLFOOukkYbxKr169sGTJkgzMqO0Rx+yYnyMbuLHcrviiLBrjtVU/AgC+q6qPX18wAUVYlOb7UFXXYhnsy4qdweWF2LAnPr6olYNduuZHxU4oIqMl5rLK9UV/lcOybFrw0EzseAxicbiYnRwvFzvjROw8cO5IbKiqx9EDuloeq4g39lOwcmNlM+157gRBtH/ahWWnM5JsNhYboCxJkupGEMYCCbZp+26xFMYKx1l1PmfHeFDgqkkU1q2kZEblMW4sZV6HlhVgQn9eWJjF7LgNiuB15dxYnoTdWD89shduO22ordiaHG/0nyaX7t2OBQP7PJMsYk0QBOEYEjtZSiIxO3o3VjzFWVknrernKLSYCJnCnKgbptmiZg1rHSrO9Zoc6YyuArGjCLBAKKJadvJ8bl2ci5llh1+Q43MfWBaP4SnK0dbZaRsBkiN0Y7XJpdKCy+DZEgRBpIN2/PXZsdE2/QQcVlCW40UFlWwsQBxHI3JZmYudqLBosuiPxYqoAn9yHtPepXnqayVTCYjfjxIHEwiGVctOjjdxscMGX/fsEr+2NvU81RlQSqzOpEHRNikd0Y1FWocgiHTTLmJ2OiMiYcOKGVHhPG1RQeVwtxSvsyP6q5oVQC9/uRMPLvgedSbuHlXsWLix2ArOviT7NHUv9GPHgWghQ5HIUixHLcGIuj/X59a5fszcWGzX8er6eHo5K/yKcrxcgG2qDTtL5xyPvfUBHFpeqNuXDdlYicJZzTI4D4IgOidk2clSrNxYbJNLJbA2LIvdWHzMjvm1bn5lLXbXtpjOTbHSWHU+V+bjcknwJZCuzOKSgBnjeqPA78E5Y/TZS0Ux11pLKKyKk2TcWAqSBPTskov+3fMxrLIIOV4XZ6VItQApyfPxQof5vNpz5WEXWXYIgsggZNnJUqxECSt2XILg44gMJmYnvlAmUqxQSzxmx0LshOOWHY/bBZdkHXdkhCRJmHv2CNx1xjD4PC543RLX1LMoNxazE4zH7OR43YhE+DnWOxQ7Y3p3gcftwgc3TIzFPklc/ElbBw3LHcQOwlt2OsY9EQTRfiDLTpYhyzIWfrtHuI8VCq2M2FHWDlbHhCKReJ0di3YRdvtlKRi5sWRZxoff7FE7oivjKpaQZFxZyvyVMbSZU0o14pZQOO7G8rp1ncAbWoxbXLCp54/+/AiM7l2Ch84/PLrP7VJFTjprxnQUKwirIzvKPREE0X4gy06W8f7Xe3DVf1YK98mcZScuNEKxaGbWQhOJ8JYdtYKyKPDZsWVHcWPxVpJXV/2IX7/8FQ4tK8CCmyYhHLuYIji8bhdXX8fJdfVNM10AomP53C41e6klyLuxtLWA7Lqxpo/sgekjxS1HODdWlrqWsm1aEufGIrVDEER6IbGTRfx72Xb8ZYFxQ0xWzLCWnYgcFQ5cbyyZTz03axeRsGVH48b6+5LNAICN1Q0A4tlYisXE73Ghnjk+KFJeBujEDmOx8Xtd8McsPoFQRM3GyvW6dc0xzQoh2o2/4ZtzZpmqiJHNNXlI6hAEkW5I7GQJ2/c34vdvrDc9xihAGYiJG22dndghLklSa7SIe2M5m2uBXxyzsykmctg5KNcHoAtSDoXtL3vatZsVMbxlJ56NleNz68SIWbq8bbHDpZ7bOiVhEjWCZK/UITcWQRDph2J2soQqiwwowNiNBfC9sNhtgNayox835FDtiCw7NU2t6mul+m9YY9nRxuwEBenzd54+VHhNsRsrit/rQo5i2WHq7OQJLDtm2D2WPayt3ViJBvNmsWGHIAgi7ZDYyRKsWi8AxtlYQNRlpLXaKCJGYmN2hNlYzubKtotQBNiyLQeY/d7YuPHUc0Akdvi5dMnz4oTDyoXX1OoQ1grj97jhj1l2AqEIWtg6Ow7ETiIuqe6FfsfnOCFhy04Wqx3KxiIIIt2Q2MkSzCoWK5i6scJ6saPE9bhdTLuIBLqpa1HEDBBv6Llsy/743GL3orXseN3mlh2P26U2wNSitex43Vo3lis2HyYby+dpE8vO7pq4FU5U8ycbyF6pQ24sgiDSD4mdLMGpZadVZ9mJ6GJvQowby23ixnJaZ4dt/dAUy8jixE5sbsr13QaWHa3A87ok5PnEYWRaqwtr2fF5XMjxxC07bICyVaAuOye7MTs/G9sLXfN9uP+ckWoxw7YiUV2QxYYdsusQBJF2KEA5S2hutfYlyWaWHZEbK6xPPRel/TpLAY+KAr/HhUAoGgzsaQ7iu6p4nlUgFIHMBEyrYkdj2dEGC3vc8awq0XVZWCuRz+OCn7HsNLcaZ2NpyfO5OQuYHcb06YIvb5ua1a4iKYttO2TZIQgi3ZBlJ0twatnR9ngKRWRdCnlQjdlx3vUcELt1lMBgxd3UHAzjYGOr7rjWcISx7ETP0Vp2tPfscUerE+eKOn5LJpYdd9yyE4rIai2dXEG7CC2saHLi8kqX0ElUGGRpRjwAqrNDEET6IbGTJdiL2YkvEnWaSsBs408FtRGoK56NJaqpY1RnJ1cQP6OIB8Xd1Nwaj5EpyeNjedQKyrHfMq3VRmvZ8WqEFIu+zk58LK9bUi07QDwzLNfrthQlXq4Sczb+c0g0Gyt71Q5pHYIg0k02frt3Sqz6TAG8Vaa2WS92jAKNFddTdAz7biyRhUWxfihCqKk1jOZg1JJSnBvvCB4IhdXeWIaWHU0FZqVQoEhkmdXZ8TKWHQBoZLKxROQwwsjrScyyk+1k851QNhZBEOmGxE6W0NhqXNlXgTX/12nETigiGwYaR+vs6McAokLHiRvLpVp2FDdWiOtFpVYyDkZ0FZS12ViimB12bO09sLDuKa/HJeysnudzCwN12aBi9h6zsRqyUyvIcYd2AwD8fHzvNphNaiDLDkEQ6YYClLOERpOeTQpstlWdJmZH5MZSkNiu55o46FaHRXYUcaBULG5qDcPnjl441+eG3+NGSzCCQCiiWpHURqAWYkdxKYljdvj32tRzIOomY+8nRzAOEM0mq64PxMbpWJadxy8YgxXbDuCYAd0yPRVDSOsQBJFuyLKTJTQGrN1YYVPLTsSWZScsy5zLLBB0JnYUi4piHalpCsYrFvvcqosoEApbpp4f0AQ2m7mx9JYdPmYHgFpYUEEkmgCoHdLZa7LzzCacCoMCvwdTBpcl1WG+rSHLDkEQ6SZ7vxE7GWbduBWsApSNYnbcLkldyH/1368w8q73sWN/EwB92wkrFOtHeVG0cnB1fYBxY3ngZ+rd6FLPNQvwg5qmp17VjaU3OGoDbtnAYmVcNhbH45IMF/x8f1wEZXsH846YuUQxOwRBpBsSO1mCHTeWbBKgHBL0xlJg3VgNgRCCYRnPfL4NgL5eD3+efvF3uxWxkwMAqK5rUcVOnk8cs2MkdrSoPbTc+uO0Qs6tCVAG+Gwvxaojki9sUUQ2qMftzj6x0yEhrUMQRJohsZMlNNrKxmLdWPqYHeNsLEkX88K6m4wQWRUU60dZrCfUnroWNasq1+tWU8ADoTDCEb5Yn0jEsCgByl6BKGIbjQKaooJuxbITt9gYZWIBvBuLfSzZGLPTEXWB0/YkBEEQyUJiJ0uwFaDMrBGKG0vJXAoJemMpsF3PFRTLR0uCMTuqZac+EG/PEAtQBqIWIyVW2K7YUWJvvALRcaCJt2SJLDsisSPyTLFih72UVWsJIjWQ1CEIIt2Q2MkS7Imd6DLREgyrLQ665PkAKJYd8XlugdiJW2CMxc4RfbrotikVlMuKFMtOQOzGCkVUy47HphtLmaNH4E7SWnbYY8zcWCJYN9bQyiLm3rJP7HREI0hHvCeCILIbEjtZgp0AZcWtpGRiuSSgKDeaFRVtBCpeRSSXvoaMsuAEBJWb3S4Jd585DBdO6CvcB8QtO/sbA6iPpcHzMTthNTvMZVPsKGjr8QCCzC2uzg6fDg8wlh1B1E5xrhdvX3ss/vCT4Zg2vIfu3rKJjqgLOuI9EQSR3ZDYyQJC4YiphUVBqZGjuLAKc7zwxSwcTmN2FPdViyBmZ2iPIlw4oa/QwqJkfJfm+eBxSZBlqJldOV7ejaUtKpiM2Klv0VZb1sfssMUIzSw7RTkeDD+kGDPH9+HcXNnYYqEjZWP1Ls0DAJw2sofFkQRBEKmFigpmAS02hA4Qd2PVxoKTi3I9qjUiZNEuQuvGUkSOtrAfEBclohiWTdUN0X0uCd0L/dhd24Kt+xsBRFPG2e7jimVHCWoWiRgWZfZeG1lRHkHqeWm+T91mKnZy4xWUKU4nfbxz3bHYsrcRI3sWZ3oqBEF0MsiykwXY6YsFxAOUlePzfR41hiYckXXVkRXElp2Y2BEUM1QsJSKvDhvQ3K0gGrezN1aNOM/nVntUBUIRtUqxIsjsiBiAt9r89fzDAQAP/mwUd4woQLlrvl/dZpaNxbaLOLxXCYpzvRjGxO5kEzefPBgAcNmx/TI8k+QpzPFiVK+SrLSgEQTRsSHLThZgp+M5EHdptIajx/s8LnXRt3ZjaSw7MdEi6sllZtlhKcrlf31yffHU878s+D7uxoqJHFH8jAg2G+vMww/BycMqdK0fvFzX85hlp0Bv2RH2xmLmneN1Y8XvpmZlvA4AjOxZgu/uOcWw9QVBEARhDVl2soBmE7Ez4pBiXDShD4C4G6s1FP2/1+1ShYRV13O92DF2Y4ncTb879TCM7FmM/ztnhLqNtZAAfCNQtrmoU1eR9vqihZ637ERfd2PdWDYtOwAvGrMREjoEQRDJQZadLMDMjfW/a4/Fa6t+AJZuRzimH4KxAjZet8TF7IQNYlldkgSXRr/ExY7esuMXWHYO6ZKLt645ljuuOJcXDXlMnR0WJb7GrubpFQtkNYNrF6G4sQr0bizRJbXzJgiCIDo2JHayADPLDhAXHYobKy52XKqQCEcihpk7bLsIBUXsiBqQqm4sRiCJLB9FGtGQy6Sec/N3aDU5fVQlvt1dhzGCOj/x+TDZWEkEKBMEQRAdn6x2Y915552QJIn7GTJkiLq/paUFs2fPRteuXVFQUIBzzjkHe/bsyeCME8NK7Cg6JaIRO37G/RKKyMKu566Y0NE2uVRidkSWnXiAcvwcUcG9ohxeK7PZWCy2i/XFpu92SZhz6mE4aViF4aGiooLdmJgds8wvkSAjCIIgOi5Z/60/bNgw7N69W/359NNP1X033ngj/ve//+Hll1/GkiVLsGvXLpx99tkZnG1itFhkYymiQ8m2ag0zMTtsNpbAsKOcq9UbisAS9eRSLCXsKSLrjM6y4xW7sRQrTCqzcDyCbCw2Fkck4hQoG4ggCKJzkfVuLI/Hg4oK/V/4tbW1eOqpp/DCCy/g+OOPBwA8/fTTOOyww7Bs2TIcddRR6Z5qwth1Y8UDlONuLEXfhMKy0I2lnKstyqe4sUTxQqrYsbTs8GKnKNcjdB8pRpaxfY3dUk7higrGKiizgkwJvD55eAUeXrQpZdclCIIg2h9Zb9nZuHEjKisr0b9/f8ycORM7duwAAKxcuRLBYBBTp05Vjx0yZAh69+6NpUuXmo4ZCARQV1fH/WQSq2acyhou6wKU2ZgdsRtL0Sub9jZw25WKzUpPLlakeAV1dsQxO3GtXJrvQ57Pg4IcvX5WLDs9inPx2W+Ox8nDysU36gCRZYclFLN+Dassxsc3T8GQisKkr0kQBEG0T7Ja7IwfPx7PPPMM5s+fj8cffxxbt27Fcccdh/r6elRVVcHn86GkpIQ7p7y8HFVVVabjzp07F8XFxepPr1692vAurLGO2eEtO8GYUPF5+Gysg03xnlkKyv7tsZYOClW1Laiub1EtIGyGkvKat+zof1XYc3p2yQXAN9lU58BmdZXkwse4ukTH20EUswMA10wZiC55Xsya2F/d1rtrnlAIEgRBEJ2DrBY706ZNw09/+lOMHDkSJ598Mt59913U1NTgv//9b1LjzpkzB7W1terPzp07UzTjxLAqKqiIF22AMmvZaQyEsK8hWrG4T9d85tzofq2oaA6GMe4PC9VzWOHSqzSXuy5gYNlh3Fi9ukTTxQsFlh1lvup7pj3G2jtO0h1vByPLzq9PHoyVt52oS1/vwmRqEQRBEJ2LrBY7WkpKSjBo0CBs2rQJFRUVaG1tRU1NDXfMnj17hDE+LH6/H0VFRdxPJrFqFxGP2QGWbdmPpVv2A4hmTamWmwNRy02h34MueXERohhVnrroSEzo3xX/uvhIbuzdtS0AeJeUIlzYbCyr1PNDYpYdkdjRVmlmxQ8bZyM76IfNWpq02VWiYOr7zxmJYwd2w/OXj7d9DYIgCKJj0K7ETkNDAzZv3owePXpgzJgx8Hq9WLhwobp/w4YN2LFjByZMmJDBWTrHMkA59inVNgdx/pPLsGLbQQCA1xO37GzbF23GeUiXXE6YKIJlfP+ueHHWURhxSInwGrm+uEhRXFJs0pJVgLJS46bAr69ho8QFKQzpIY6fGVxuX3QaubGM6NstH/+5fDyOGdjN9jUIgiCIjkFWZ2P9+te/xumnn44+ffpg165duOOOO+B2uzFjxgwUFxfjsssuw0033YTS0lIUFRXh2muvxYQJE9pVJhZgP2bnx5pmbrvX7VKDf7fFOo/37JKHupageoxWo+QI6uAAvCBRhItkYdlhx1IsOkLLjqZw4ewpA+GWJLWOzlvXHIMPv63GlZP66841grU62W0wShAEQXROslrs/PDDD5gxYwb279+P7t2749hjj8WyZcvQvXt3AMBf/vIXuFwunHPOOQgEAjj55JPx2GOPZXjWzrFbZ6c1xMe++NwScn1RwaGklvcqzcV3u+PCRStSjPos1TXHBZIkqM0jsuywYmhs31IA0ZYRWho0lp08nwc3nTRYfT+yZwlG9iwRzssI1uHlpSKBBEEQhAlZLXbmzZtnuj8nJwePPvooHn300TTNqG2wsuxoqx8reN0uVBTnctt6dsnDxj3xNHNtAT0jl08tI3YUrGJ2AGDRryahuj6AQeWFwusB5gX+EoWtKeSz4cYiCIIgOi+0SmQB1kUFxdu9bhcGlRdw2/p3z+dibex0avB5XLj99KEAwKVss+MYiZ3+3QtwVP+upuP/cvJA60k4hK2faCdmhyAIgui8ZLVlp7NglY1l1N7A63FhYBkvdo7s0wXPfr5Nfe+y0Rohz+fGaSMrMa5vKboXxjuHS7C27FjxxW9PQFlRTkLnmhFh1E6icyMIgiA6B/QncRag1NnJF8S7AMbWGb/bhTwfr1cLc7ycwBGJnQsn9OHejzikGABQVpTDCSurOjt2aAuhA/CWHYIgCIIwg8ROFqC4sfINqgmL6sYAgDfWE0rJijqqfzRImBU4IsPO3WcOx9I5x6vvr5kidjNxMTtZ1jwzQmqHIAiCsAm5sTJAbVMQr6/+AaePqkTXAr8qdgr8HlTXRysa+9wuPH3JWADmMTsAMG/WBDz16Vb8fvphuuON4ll6FOfi2uMHwu9xYbxBzA0rJ7KtUzhJHYIgCMIuJHYywHXzVmPJ93vxv7W78erVR6uNQPP8cTfWYzOPUAvgGcbsxITM4b1K8LcZo9XtrMvJzP30Kyb9WwRrPcm2sJg+mnYQBEEQBGEEiZ0MsOT7vQCAldujlZBDsfYJOUyDTFEVZC1GKdfs8aL6OHbhxU52qZ3x/bti7tkjMKB7gfXBBEEQRKeGYnaygFA4Kip8THE8l0scKMxi5KJy2bTsWMG2gzCKJxJx1aQBAIAzD69M+Np2mDGuN8b1K23TaxAEQRDtH7LsZAGhSFTssA0t3RYZVQAvjlisKh/bJcfrxqJfTYJLkgyvJeJXJw3CpEHdMbp3ScLXJgiCIIhUQWInw9Q2BxGKRN1YvGUnfoyRB8moJ5TbRuVju/RPwE3kdbswYYB5oUGCIAiCSBckdjLMqLs+UF/72ZgdG5YdIzeWxMXskKeSIAiC6NzQSphFsJYdOxlVRq4lVgNRdWGCIAiis0NiJ4vwpypAmbXsGLi6CIIgCKKzQGIni+BidrgqyEZuLPH2VGVjEQRBEERHgMROFuE0ZsfQjZWiOjsEQRAE0REgsZNFGGVjGekV46KC8ddk2SEIgiA6OyR2sgSXxFth7FRQtlNUkLKxCIIgiM4OrYRZgsft4jOwLDqXA/YClMmyQxAEQXR2SOxkCR6XxIkUly3LjkFRQRfF7BAEQRCEAomdLMHtkvj6ODYClI2ytCSK2SEIgiAIFRI7bciba37Ewws34kBjq+WxXrfL0P3kVK+4qc4OQRAEQahQu4g25E8fbMDOA82YMKArSvPNu3NHLTtiN5aRBccIitkhCIIgiDgkdtqQXl3ysPNAM3442ISxfaNiR5Zl4bFejdjh3Vjx40b1LMa0ET3Qt2u+4XUpG4sgCIIg4pDYaUN6dskFAOw80Kxuaw1HhMe63doAZWafJiX9qkkDTK9LdXYIgiAIIg792d+G9OySBwB4cMH3uPWVtQCAQEgsdrwuTcyOQbsIO5YaqqBMEARBEHFI7LQhvUpz1dcvfbkT9S1BtBqIHbdLMsyiYvWKHa8U9cYiCIIgiDgkdtoQxbKjEAhFDMWOR1Mg0KjOjh3LjossOwRBEAShQjE7bUgvgdgJGokdjSgxqrNjx1LD1euhAGWCIAiik0Nipw0pK/Rz71tDEQQNApS19XDcXOq5eLsRLqqzQxAEQRAq9Gd/G+JySbjz9KHq+0AobOzG0ogYVuA4teyQG4sgCIIg4pDYaWMuPqYfDimJBiq3hiIIhMLC4zwuF1hZYlRnx22jwCClnhMEQRBEHHJjpQGfJ6op57y2DmP6dBEeY+bG4iw7NtxS1AiUIAiCIOKQ2EkD/pjY+XpXHb7eVSc8Rpt6LknimB074kXixBEZ7wiCIIjOTVavhHPnzsXYsWNRWFiIsrIynHXWWdiwYQN3zOTJkyFJEvdz1VVXZWjGYhTLjhlmKeWSQbFBI8iyQxAEQRBxslrsLFmyBLNnz8ayZcuwYMECBINBnHTSSWhsbOSOu+KKK7B792715/7778/QjMX4bYkde6LEZStAOf6aYnYIgiCIzk5Wu7Hmz5/PvX/mmWdQVlaGlStXYuLEier2vLw8VFRUpHt6tvF73JbH2E0RtyOKKBuLIAiCIOJktWVHS21tLQCgtLSU2/7888+jW7duGD58OObMmYOmpqZMTM8Qe26sVFp2qF0EQRAEQShktWWHJRKJ4IYbbsAxxxyD4cOHq9t//vOfo0+fPqisrMTatWtx6623YsOGDXjttdcMxwoEAggEAur7ujpx0HCqsOXGshlIbEcU8TE77UrPEgRBEETKaTdiZ/bs2Vi/fj0+/fRTbvusWbPU1yNGjECPHj1wwgknYPPmzRgwYIBwrLlz5+Kuu+5q0/mypNSyYyNA2WnFZYIgCILoyLSLP/uvueYavP322/joo4/Qs2dP02PHjx8PANi0aZPhMXPmzEFtba36s3PnzpTOV4s9y07qYnYoG4sgCIIg4mS1ZUeWZVx77bV4/fXXsXjxYvTr18/ynDVr1gAAevToYXiM3++H3+833J9qbAUo23Q32Skq6LQIIUEQBEF0ZLJa7MyePRsvvPAC3nzzTRQWFqKqqgoAUFxcjNzcXGzevBkvvPACTj31VHTt2hVr167FjTfeiIkTJ2LkyJEZnn0cu26scf26Wh5nr10EWXYIgiAIQiGrxc7jjz8OIFo4kOXpp5/GxRdfDJ/Phw8//BAPPfQQGhsb0atXL5xzzjm47bbbMjBbY+y4sdxuCf265ePDmyaha77P8DinbiyK2SEIgiA6O1ktdmRZNt3fq1cvLFmyJE2zSRw7lh3FGjOwrMD0OLcNdxerbygbiyAIgujs0EqYBuzE7NjFToa6iyw7BEEQBKFCYicN2HFj2cWeZYdidgiCIAhCgcROGrDjxrLw2KnYsey4qYIyQRAEQaiQ2EkDqbTs2CkqyMXsUOo5QRAE0ckhsZMGbFl2YM+0M6pXieUxLioqSBAEQRAqWZ2N1VFIRYDyhzdNwrZ9jRjbt9TyWL4RKOlZgiAIonNDK2Ea8Hv5x3z0AEHxQAvDzsCyAkwdWm7remxcD1l2CIIgiM4OiZ004GfUx8tXTcAzl4xr0+tJFKBMEARBECokdtIAG0MzqKxQGMNjMxnLFm5KPScIgiAIFRI7aSDC5JXn+MSP3KpatBPYhC2y7BAEQRCdHRI7aYDVMT47hXKSJMJcj9pFEARBEJ0dWgnTQLcCv/paMqiTk0LDDmdJojo7BEEQRGeHUs/TwOCKQtx71nBUFOWk5XqscCI3FkEQBNHZIbGTJi44qo/p/mMP7ZbCqzGWHRI7BEEQRCeHxE4W8MLl43H0wNSJnQhZdgiCIAhChWJ2MkxhjielQgfg3VhGMUIEQRAE0VkgsZNh8nzJt5LQQsYcgiAIgohDYidD/P2CMejTNQ9P/uLIlI89uncXjOtXip+O6ZnysQmCIAiivSHJqaxm106pq6tDcXExamtrUVRUlOnpEARBEARhA7vrN1l2CIIgCILo0JDYIQiCIAiiQ0NihyAIgiCIDg2JHYIgCIIgOjQkdgiCIAiC6NCQ2CEIgiAIokNDYocgCIIgiA4NiR2CIAiCIDo0JHYIgiAIgujQkNghCIIgCKJDQ2KHIAiCIIgODYkdgiAIgiA6NCR2CIIgCILo0JDYIQiCIAiiQ+PJ9ASyAVmWAURbxRMEQRAE0T5Q1m1lHTeCxA6A+vp6AECvXr0yPBOCIAiCIJxSX1+P4uJiw/2SbCWHOgGRSAS7du1CYWEhJElK2bh1dXXo1asXdu7ciaKiopSNS+ihZ50e6DmnB3rO6YOedXpoq+csyzLq6+tRWVkJl8s4MocsOwBcLhd69uzZZuMXFRXRP6I0Qc86PdBzTg/0nNMHPev00BbP2cyio0ABygRBEARBdGhI7BAEQRAE0aEhsdOG+P1+3HHHHfD7/ZmeSoeHnnV6oOecHug5pw961ukh08+ZApQJgiAIgujQkGWHIAiCIIgODYkdgiAIgiA6NCR2CIIgCILo0JDYIQiCIAiiQ0Nipw159NFH0bdvX+Tk5GD8+PH44osvMj2ldsXHH3+M008/HZWVlZAkCW+88Qa3X5Zl3H777ejRowdyc3MxdepUbNy4kTvmwIEDmDlzJoqKilBSUoLLLrsMDQ0NabyL7Gfu3LkYO3YsCgsLUVZWhrPOOgsbNmzgjmlpacHs2bPRtWtXFBQU4JxzzsGePXu4Y3bs2IHp06cjLy8PZWVluPnmmxEKhdJ5K1nN448/jpEjR6pF1SZMmID33ntP3U/PuG247777IEkSbrjhBnUbPevUcOedd0KSJO5nyJAh6v6ses4y0SbMmzdP9vl88r/+9S/566+/lq+44gq5pKRE3rNnT6an1m5499135d/97nfya6+9JgOQX3/9dW7/fffdJxcXF8tvvPGG/NVXX8lnnHGG3K9fP7m5uVk95pRTTpFHjRolL1u2TP7kk0/kgQMHyjNmzEjznWQ3J598svz000/L69evl9esWSOfeuqpcu/eveWGhgb1mKuuukru1auXvHDhQvnLL7+UjzrqKPnoo49W94dCIXn48OHy1KlT5dWrV8vvvvuu3K1bN3nOnDmZuKWs5K233pLfeecd+fvvv5c3bNgg//a3v5W9Xq+8fv16WZbpGbcFX3zxhdy3b1955MiR8vXXX69up2edGu644w552LBh8u7du9WfvXv3qvuz6TmT2Gkjxo0bJ8+ePVt9Hw6H5crKSnnu3LkZnFX7RSt2IpGIXFFRIT/wwAPqtpqaGtnv98svvviiLMuy/M0338gA5BUrVqjHvPfee7IkSfKPP/6Ytrm3N6qrq2UA8pIlS2RZjj5Xr9crv/zyy+ox3377rQxAXrp0qSzLUWHqcrnkqqoq9ZjHH39cLioqkgOBQHpvoB3RpUsX+Z///Cc94zagvr5ePvTQQ+UFCxbIkyZNUsUOPevUcccdd8ijRo0S7su250xurDagtbUVK1euxNSpU9VtLpcLU6dOxdKlSzM4s47D1q1bUVVVxT3j4uJijB8/Xn3GS5cuRUlJCY488kj1mKlTp8LlcmH58uVpn3N7oba2FgBQWloKAFi5ciWCwSD3rIcMGYLevXtzz3rEiBEoLy9Xjzn55JNRV1eHr7/+Oo2zbx+Ew2HMmzcPjY2NmDBhAj3jNmD27NmYPn0690wB+n1ONRs3bkRlZSX69++PmTNnYseOHQCy7zlTI9A2YN++fQiHw9wHCADl5eX47rvvMjSrjkVVVRUACJ+xsq+qqgplZWXcfo/Hg9LSUvUYgicSieCGG27AMcccg+HDhwOIPkefz4eSkhLuWO2zFn0Wyj4iyrp16zBhwgS0tLSgoKAAr7/+OoYOHYo1a9bQM04h8+bNw6pVq7BixQrdPvp9Th3jx4/HM888g8GDB2P37t246667cNxxx2H9+vVZ95xJ7BAEoTJ79mysX78en376aaan0iEZPHgw1qxZg9raWrzyyiu46KKLsGTJkkxPq0Oxc+dOXH/99ViwYAFycnIyPZ0OzbRp09TXI0eOxPjx49GnTx/897//RW5ubgZnpofcWG1At27d4Ha7dVHne/bsQUVFRYZm1bFQnqPZM66oqEB1dTW3PxQK4cCBA/Q5CLjmmmvw9ttv46OPPkLPnj3V7RUVFWhtbUVNTQ13vPZZiz4LZR8RxefzYeDAgRgzZgzmzp2LUaNG4a9//Ss94xSycuVKVFdX44gjjoDH44HH48GSJUvw8MMPw+PxoLy8nJ51G1FSUoJBgwZh06ZNWfc7TWKnDfD5fBgzZgwWLlyobotEIli4cCEmTJiQwZl1HPr164eKigruGdfV1WH58uXqM54wYQJqamqwcuVK9ZhFixYhEolg/PjxaZ9ztiLLMq655hq8/vrrWLRoEfr168ftHzNmDLxeL/esN2zYgB07dnDPet26dZy4XLBgAYqKijB06ND03Eg7JBKJIBAI0DNOISeccALWrVuHNWvWqD9HHnkkZs6cqb6mZ902NDQ0YPPmzejRo0f2/U6nNNyZUJk3b57s9/vlZ555Rv7mm2/kWbNmySUlJVzUOWFOfX29vHr1ann16tUyAPnBBx+UV69eLW/fvl2W5WjqeUlJifzmm2/Ka9eulc8880xh6vno0aPl5cuXy59++ql86KGHUuq5hquvvlouLi6WFy9ezKWQNjU1qcdcddVVcu/eveVFixbJX375pTxhwgR5woQJ6n4lhfSkk06S16xZI8+fP1/u3r07peoy/OY3v5GXLFkib926VV67dq38m9/8RpYkSf7ggw9kWaZn3Jaw2ViyTM86VfzqV7+SFy9eLG/dulX+7LPP5KlTp8rdunWTq6urZVnOrudMYqcN+dvf/ib37t1b9vl88rhx4+Rly5Zlekrtio8++kgGoPu56KKLZFmOpp///ve/l8vLy2W/3y+fcMIJ8oYNG7gx9u/fL8+YMUMuKCiQi4qK/r+9uwuJYo3DAP7Muuw2u1RuutRgEoViWiCVIZZdlFTuRaTshcUWowaSVogZQUFfRGxESXcbQhlRJBh4k31QN0FKH/QhUVsgtXazQlBJWpm1/y4ODYzpscPRdc6c5wcD7rwf89+5eph511eqqqrk06dPU/BtrGu0ewxAWlpajD5fvnyRuro68fl84vF4pLy8XOLxuGmeWCwmgUBAVFWV9PR0aWxslOHh4SR/G+uqrq6WefPmicvlEr/fLyUlJUbQEeE9nkwjww7v9cSoqKgQTdPE5XJJRkaGVFRUSE9Pj9FupfusiIhM7LMiIiIiIuvgmh0iIiKyNYYdIiIisjWGHSIiIrI1hh0iIiKyNYYdIiIisjWGHSIiIrI1hh0iIiKyNYYdIvrPiMViUBQFT58+nbRrVFZWoqysbNLmJ6LkY9ghoqSprKyEoii/HaWlpX80PjMzE/F4HIsXL57kSonITpxTXQAR/b+UlpaipaXFdM7tdv/R2JSUFO46TUT/GJ/sEFFSud1uzJkzx3T4fD4AgKIoiEQiCAQCUFUVCxYswJUrV4yxI19jffjwAaFQCH6/H6qqIjs72xSknj17hjVr1kBVVaSlpaGmpgYDAwNG+48fP7B7926kpqYiLS0Ne/fuxcgddBKJBMLhMObPnw9VVZGfn2+qabwaiGjqMewQkaUcOHAAwWAQ3d3dCIVC2LRpE6LR6Jh9X7x4gevXryMajSISiSA9PR0AMDg4iPXr18Pn8+Hhw4doa2vD7du3sXPnTmP8qVOncP78eZw7dw53797F+/fv0d7ebrpGOBzGhQsXcObMGTx//hwNDQ3YsmUL7ty5M24NRGQRE761KBHRGHRdl5SUFPF6vabj2LFjIvLXDuzbt283jSksLJTa2loREXnz5o0AkCdPnoiIyIYNG6SqqmrUazU3N4vP55OBgQHjXEdHhzgcDunr6xMREU3T5MSJE0b78PCwzJ07VzZu3CgiIl+/fhWPxyNdXV2mubdt2yabN28etwYisgau2SGipFq9ejUikYjp3KxZs4y/i4qKTG1FRUVj/vqqtrYWwWAQjx8/xrp161BWVoYVK1YAAKLRKPLz8+H1eo3+K1euRCKRwKtXrzBt2jTE43EUFhYa7U6nEwUFBcarrJ6eHnz+/Blr1641Xffbt29YsmTJuDUQkTUw7BBRUnm9XmRlZU3IXIFAAL29vbh27Rpu3bqFkpIS7NixAydPnpyQ+X+t7+no6EBGRoap7dei6smugYj+Pa7ZISJLuXfv3m+fc3Nzx+zv9/uh6zouXryI06dPo7m5GQCQm5uL7u5uDA4OGn07OzvhcDiQk5ODmTNnQtM03L9/32j//v07Hj16ZHzOy8uD2+3G27dvkZWVZToyMzPHrYGIrIFPdogoqYaGhtDX12c653Q6jUW9bW1tKCgoQHFxMS5duoQHDx7g7Nmzo8518OBBLFu2DIsWLcLQ0BCuXr1qBKNQKIRDhw5B13UcPnwY7969w65du7B161bMnj0bAFBfX4/jx48jOzsbCxcuRFNTEz5+/GjMP336dOzZswcNDQ1IJBIoLi5Gf38/Ojs7MWPGDOi6/rc1EJE1MOwQUVLduHEDmqaZzuXk5ODly5cAgCNHjqC1tRV1dXXQNA2XL19GXl7eqHO5XC7s27cPsVgMqqpi1apVaG1tBQB4PB7cvHkT9fX1WL58OTweD4LBIJqamozxjY2NiMfj0HUdDocD1dXVKC8vR39/v9Hn6NGj8Pv9CIfDeP36NVJTU7F06VLs379/3BqIyBoUkRH/VIKIaIooioL29nZu10BEE4prdoiIiMjWGHaIiIjI1rhmh4gsg2/ViWgy8MkOERER2RrDDhEREdkaww4RERHZGsMOERER2RrDDhEREdkaww4RERHZGsMOERER2RrDDhEREdkaww4RERHZ2k8XFSFtaoiFqwAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACA+UlEQVR4nO3dd3zTdf4H8FfSJulM94SWtqyyt6WyBZkORE/lwANBQQ4Xbu4U98HPdZ53gnqnoJ6KoqInKIqy9yybQqEthe6VdKYZ398fyffbpE3adKfx9Xw8+ng035VPo5QX78+SCYIggIiIiMhNyTu6AURERERtiWGHiIiI3BrDDhEREbk1hh0iIiJyaww7RERE5NYYdoiIiMitMewQERGRW2PYISIiIrfGsENERERujWGHiMhFzZ8/H3FxcR3dDKJOj2GHyIXIZDKnvnbs2IGMjAybY3K5HMHBwZg2bRr2799f79kvvPCCzfU+Pj7o27cvnn32WWi12nrXnzlzBnPnzkWXLl2gUqkQHR2NOXPm4MyZM+3xUTRZXl4ennjiCSQmJsLHxwe+vr4YNmwYXnnlFZSWlrbqe61evRrr1q2rd3zHjh02n7FCoUBCQgL+9Kc/4fLly63ahrZWWlqKRYsWISwsDL6+vpgwYQKOHTvW0c0iahbPjm4AEdX69NNPbV5/8skn2Lp1a73jffr0QVVVFQBg9uzZmD59OoxGIy5cuIDVq1djwoQJOHz4MAYMGFDvPdasWQM/Pz+Ul5fjl19+wauvvopt27Zh7969kMlkAIBvv/0Ws2fPRnBwMBYuXIj4+HhkZGTgww8/xNdff43169fjtttua6NPoekOHz6M6dOno7y8HHPnzsWwYcMAAEeOHMGqVauwa9cu/PLLL632fqtXr0ZoaCjmz59v9/zDDz+MESNGQK/X49ixY/jggw+wefNmnDp1CtHR0a3WjrZiMpkwY8YMnDhxAk8++SRCQ0OxevVqjB8/HkePHkXPnj07uolETSMQkctaunSp4OiPaXp6ugBAeP31122O//TTTwIAYcmSJTbHn3/+eQGAUFBQYHN81qxZAgBh3759giAIQlpamuDj4yMkJiYK+fn5NtcWFBQIiYmJgq+vr3Dp0qWW/nitoqSkROjSpYsQEREhnDt3rt753Nxc4eWXX26V96qoqBAEQRD69esnjBs3rt757du3CwCEDRs22Bx/5513BADC3/72tya937x584Ru3bo1t7nN9uWXX9b7OfLz84XAwEBh9uzZ7d4eopZiNxaRmxkzZgwA4NKlS05df8MNNwAA0tPTAQCvv/46Kisr8cEHHyAsLMzm2tDQULz//vuoqKjAa6+91uiz8/PzsXDhQkRERMDLywuDBg3Cxx9/bHON2B33xhtv4IMPPkD37t2hUqkwYsQIHD58uNH3eP/993Ht2jW89dZbSExMrHc+IiICzz77rPT6+++/x4wZMxAdHQ2VSoXu3bvj5ZdfhtFotLlv/Pjx6N+/P44ePYqxY8fCx8cHf/nLXxAXF4czZ85g586dUnfV+PHjG2xj3c8YMFeH+vXrJ3URLl261KnuNpPJhLfffhv9+vWDl5cXIiIisHjxYpSUlDR439dffw2ZTIadO3fWO/f+++9DJpPh9OnT0rURERGYNWuWdE1YWBjuvPNOfP/999DpdI22k8iVsBuLyM1kZGQAAIKCgpy6XgxFISEhAIAffvgBcXFxUmiqa+zYsYiLi8PmzZsbfG5VVRXGjx+PtLQ0PPjgg4iPj8eGDRswf/58lJaW4pFHHrG5/vPPP0dZWRkWL14MmUyG1157DbNmzcLly5ehUCgcvs///vc/eHt744477nDq5123bh38/Pzw2GOPwc/PD9u2bcOKFSug1Wrx+uuv21xbVFSEadOm4e6778bcuXMRERGB8ePH46GHHoKfnx/++te/AjAHqobU/YxfeOEFvPjii5g0aRKWLFmC1NRUrFmzBocPH8bevXsb/HkXL16MdevW4d5778XDDz+M9PR0/Otf/8Lx48cbvHfGjBnw8/PDV199hXHjxtmc+/LLL9GvXz/0798fAHD8+HEMHToUcrntv4evu+46fPDBB7hw4YLdLlIil9XRpSUicsyZbqwXX3xRKCgoEHJzc4Xdu3cLI0aMsNuVInZjpaamCgUFBUJ6errw/vvvCyqVSoiIiBAqKiqE0tJSAYBw6623NtiuW265RQAgaLVah9e8/fbbAgDhv//9r3SspqZGSE5OFvz8/KR7xZ8jJCREKC4ulq79/vvvBQDCDz/80GBbgoKChEGDBjV4jbXKysp6xxYvXiz4+PgI1dXV0rFx48YJAIT33nuv3vWNdWN99NFHQkFBgZCdnS1s3rxZiIuLE2QymXD48GEhPz9fUCqVwuTJkwWj0Sjd+69//Uu6V1S3G2v37t0CAOGzzz6zed8tW7bYPV7X7NmzhfDwcMFgMEjHcnJyBLlcLrz00kvSMV9fX2HBggX17t+8ebMAQNiyZUuD70PkatiNRdTJPf/88wgLC0NkZCTGjBmDc+fO4c0333RY6ejduzfCwsIQHx+PxYsXo0ePHti8eTN8fHxQVlYGAPD392/wPcXz9mZxiX788UdERkZi9uzZ0jGFQoGHH34Y5eXl9bpT7rrrLptqlFhZamwWk1arbbS91ry9vaXvy8rKUFhYiDFjxqCyshLnz5+3uValUuHee+91+tmiBQsWICwsDNHR0ZgxYwYqKirw8ccfY/jw4fj1119RU1ODRx991KZycv/990OtVjdYMduwYQMCAgJw4403orCwUPoaNmwY/Pz8sH379gbbdddddyE/Px87duyQjn399dcwmUy46667pGNVVVVQqVT17vfy8pLOE3Um7MYi6uQWLVqEP/zhD6iursa2bdvwzjvv1Bt/Yu2bb76BWq2GQqFA165d0b17d+mcGBrE0OOIM6EoMzMTPXv2rNcV0qdPH+m8tdjYWJvXYvBpbCyKWq1utL3Wzpw5g2effRbbtm2rF9Y0Go3N6y5dukCpVDr9bNGKFSswZswYeHh4IDQ0FH369IGnp/nXrfhz9+7d2+YepVKJhISEep+LtYsXL0Kj0SA8PNzu+fz8fOnnsA4kSqUSwcHBmDp1KgICAvDll19i4sSJAMxdWIMHD0avXr2k6729ve2Oy6murpbOE3UmDDtEnVzPnj0xadIkAMBNN90EDw8PPPPMM5gwYQKGDx9e7/qxY8ciNDTU7rMCAgIQFRWFkydPNvieJ0+eRJcuXaBWq1v+A1h4eHjYPS4IQoP3JSYmIiUlBTU1NY0Gk9LSUowbNw5qtRovvfQSunfvDi8vLxw7dgxPP/00TCaTzfXN/Ut9wIAB0n+T1mQymRAeHo7PPvvM7nlxQPkjjzxiMxB83Lhx2LFjB1QqFWbOnImNGzdi9erVyMvLw969e/G3v/3N5jlRUVHIycmp93zxWGeYPk9kjWGHyM389a9/xb///W88++yz2LJlS5Pvv+mmm/Dvf/8be/bswejRo+ud3717NzIyMrB48eIGn9OtWzecPHkSJpPJprojdhV169atyW2z5+abb8b+/fvxzTff2HSZ2bNjxw4UFRXh22+/xdixY6Xj1rOknCGuR9Qc4s+dmpqKhIQE6XhNTQ3S09MbDEndu3fHr7/+ilGjRjUYxJ566inMnTtXem3dPXjXXXfh448/xm+//YZz585BEASbLiwAGDx4MHbv3l3vv93Bgwfh4+NjUwUi6gw4ZofIzQQGBmLx4sX4+eefkZKS0uT7n3zySXh7e2Px4sUoKiqyOVdcXIwHHngAPj4+ePLJJxt8zvTp05Gbm4svv/xSOmYwGPDPf/4Tfn5+9WYENdcDDzyAqKgoPP7447hw4UK98/n5+XjllVcA1FaPrKtFNTU1WL16dZPe09fXt9mrMk+aNAlKpRLvvPOOTTs+/PBDaDQazJgxw+G9d955J4xGI15++eV65wwGg9Smvn37YtKkSdKXuMii+P7BwcH48ssv8eWXX+K6665DfHy8zbPuuOMO5OXl4dtvv5WOFRYWYsOGDbj55pvtjuchcmWs7BC5oUceeQRvv/02Vq1ahfXr1zfp3p49e+Ljjz/GnDlzMGDAgHorKBcWFuKLL76wGetjz6JFi/D+++9j/vz5OHr0KOLi4vD1119j7969ePvtt5s0qLghQUFB2LhxI6ZPn47BgwfbrKB87NgxfPHFF0hOTgYAXH/99QgKCsK8efPw8MMPQyaT4dNPP220q6yuYcOGYc2aNXjllVfQo0cPhIeHS2vpNCYsLAzLly/Hiy++iKlTp+KWW25BamoqVq9ejREjRthUZOoaN24cFi9ejJUrVyIlJQWTJ0+GQqHAxYsXsWHDBvzjH/9odAq+QqHArFmzsH79elRUVOCNN96od80dd9yBkSNH4t5778XZs2elFZSNRiNefPFFp35OIpfSoXPBiKhBzVlBWTR//nzBw8NDSEtLEwTB8QrKjpw8eVKYPXu2EBUVJSgUCiEyMlKYPXu2cOrUKafbn5eXJ9x7771CaGiooFQqhQEDBghr1651+ucAIDz//PNOvVd2drawbNkyoVevXoKXl5fg4+MjDBs2THj11VcFjUYjXbd3715h5MiRgre3txAdHS089dRTws8//ywAELZv3y5dN27cOKFfv3523ys3N1eYMWOG4O/vLwCQpqE7WkHZnn/9619CYmKioFAohIiICGHJkiVCSUmJzTWOVlD+4IMPhGHDhgne3t6Cv7+/MGDAAOGpp54SsrOzG31fQRCErVu3CgAEmUwmZGVl2b2muLhYWLhwoRASEiL4+PgI48aNEw4fPuzU84lcjUwQmvhPGiIiIqJOhGN2iIiIyK0x7BAREZFbY9ghIiIit8awQ0RERG6NYYeIiIjcGsMOERERuTUuKgjzfjPZ2dnw9/dv0TLwRERE1H4EQUBZWRmio6PrbTpsjWEHQHZ2NmJiYjq6GURERNQMWVlZ6Nq1q8PzDDuAtGx9VlZWq+7iTERERG1Hq9UiJiam0e1nGHZQu4OxWq1m2CEiIupkGhuCwgHKRERE5NYYdoiIiMitMewQERGRW2PYISIiIrfWoWFn5cqVGDFiBPz9/REeHo6ZM2ciNTXV5prq6mosXboUISEh8PPzw+233468vDyba65cuYIZM2bAx8cH4eHhePLJJ2EwGNrzRyEiIiIX1aFhZ+fOnVi6dCkOHDiArVu3Qq/XY/LkyaioqJCuWbZsGX744Qds2LABO3fuRHZ2NmbNmiWdNxqNmDFjBmpqarBv3z58/PHHWLduHVasWNERPxIRERG5GJkgCEJHN0JUUFCA8PBw7Ny5E2PHjoVGo0FYWBg+//xz3HHHHQCA8+fPo0+fPti/fz9GjhyJn376CTfddBOys7MREREBAHjvvffw9NNPo6CgAEqlstH31Wq1CAgIgEaj4dRzIiKiTsLZv79dasyORqMBAAQHBwMAjh49Cr1ej0mTJknXJCYmIjY2Fvv37wcA7N+/HwMGDJCCDgBMmTIFWq0WZ86csfs+Op0OWq3W5ouIiIjck8uEHZPJhEcffRSjRo1C//79AQC5ublQKpUIDAy0uTYiIgK5ubnSNdZBRzwvnrNn5cqVCAgIkL64VQQREZH7cpmws3TpUpw+fRrr169v8/davnw5NBqN9JWVldXm70lEREQdwyW2i3jwwQexadMm7Nq1y2Yjr8jISNTU1KC0tNSmupOXl4fIyEjpmkOHDtk8T5ytJV5Tl0qlgkqlauWfgoiIiFxRh1Z2BEHAgw8+iI0bN2Lbtm2Ij4+3OT9s2DAoFAr89ttv0rHU1FRcuXIFycnJAIDk5GScOnUK+fn50jVbt26FWq1G37592+cHISIiIpfVoZWdpUuX4vPPP8f3338Pf39/aYxNQEAAvL29ERAQgIULF+Kxxx5DcHAw1Go1HnroISQnJ2PkyJEAgMmTJ6Nv376455578NprryE3NxfPPvssli5dyuoNERF1eoIgIEdTDT8vT6i9FB3dnE6pQ6eeO9qldO3atZg/fz4A86KCjz/+OL744gvodDpMmTIFq1evtumiyszMxJIlS7Bjxw74+vpi3rx5WLVqFTw9nctynHpORESu6tH1x/FdSjYAYFKfCPz7T8Ma3eX798LZv79dap2djsKwQ0RErmrwS7+gtFIvvd715ATEhvh0YItcR6dcZ4eIiIhqlVTUSEEnQm0emrHtfB40VuGHGsewQ0RE5KIuF5q3T4oO8MLwOPOCuy/8cBb3f3qkI5tlQ1OlR1m1a4cvhh0iIiIXlW4JO/FhvugR5icdP5ReDKOp40ehVOuNmPDGDkx9e7dLtMcRhh0iIiIXlV5YDgCID/VFj3A/m3N52uqOaJKNczlaFFfU4FppFXJdoD2OMOwQERG5qMsFlspOqB8SwnxtzmUWVXZEk2xcsrQPADILKxq4smMx7BAREbmoM9nmjap7RfihT6Qac5JipXNZxR0fdi7klUnfZ7pAexxh2CEiInJBheU6XCmuhEwGDIoJhFwuw6u3DZACzxUXCBfnc2vDTkYRKztERERtLjW3DDmaqo5uRqtIuVIKAOgR5mezcnI3yxo7/9qehowO7jpKzdVK37+/8zJSsko7rjENYNghIiK3cK20ClPe3oXklds6uimt4nBGMQBgSGygzXHrgcqvbD7bnk2ykVlUgTytzubYfR8fQbXe2EEtcoxhh4iI3MLBy0XS9yYXngbtjMsF5fh4fwYAYFSPUJtz43qFY9aQLgDMU9Cb87NW641Iyy9DWn55s6aMn8gqxd0fHAAAxAR7S8cLy3XYePxak5/X1hh2iIjILRSW11YZKmoMHdiSlvtkfyaq9SZc3z0ENw+MtjnnIZfh/+4YCG+FB7TVBvR89idsP5/v9LMNRhMm/30XJr21C5Pe2ok/f3a0ye1b8b8zyNGYp5rfPSIWXy1Oxh8tY4nWH7rS5Oe1NYYdIiJyC9mlteu8lFW3POxoKvW47+Mj+OxgZouf1VTHr5QAAO6+LhZyef1NPxUecsQGm8fuGE0C7l13GJlODhDOK9PZDG4+klFic/6LQ1dw/ydHUOkgMJpMAk5Yjc2Z2Ccc18UH49GJPQEAJ65qUFCms3tvR2HYISKiTu3UVQ02HMmStlYAAG0rbF+wbl8Gfj2Xh3d+u9jiZzWFzmDE2RzzwN/BXQMdXnfLYNuKz0+nc516fq6lIqPyNEeA4soa6I0mAIAgCFj+7SlsPZuHLw5l2b0/22oA+IYHkpEYad6AM1zthYFdAwAA21OdrzS1B8+ObgAREVFL3PXBflTW2A6K1Va1rLKjMxjx6QFzRSdPq4OmUo8AH0Ujd7WOs9la6I0Cgn2VNuNh6lo4Oh5dAr1xPrcM7+28hPM5WofXWsu3rHTcJ0qNU9c0MJoEFJXXIDLAS9qeAjBvQmpPWr55Veee4X4YYdmvSzShdzhOXtVg54UC3Dk8xqn2tAdWdoiIqNPSGYz1gg6AFm9MuelEjs0YoFSrxfPamthFNKhrAGSy+l1YIi+FB2YO6YIRcUEAbNe8ERWW6+otPihu6xAd6IVQPyUAIL/MfOxIZm2XlqNFAsWwU3f7CgAYmRACADiaUQJBcJ1B4qzsEBFRp3XFwZYJLenGEgQBH+1NBwDIZYBJMIed6+KDG7mzdYhr1QyOCXLq+j5R5m6ktPxy6AxGqDw9AABHM0twx3v7IAjA8mmJWDyuOwBI08XD/b0Q7u+FPK0OBWU6fJ9yDU99fVJ6rhhqAOB8rhYL1x2BtloPnd7c5WUv7AyOCYSnXIZcbTWulVaha5BPE3/6tsHKDhERdVrW43TuHxOPiYnhAFo2QPmHkzk4k62Fl0KOu0aYu2Ke++601K3V1k5c1QAABsUEOHV9VIAX1F6eMJgEzP3PQSz7MgUGowl70wohFld2XigAYK6EnbN0d0UGeCHMXwXAXO15/edUm+deLiiXprW/9csFXCutQlm1ATVGE+Sy+lPiAcBb6YF+0ebwNfc/B6GpavnYqdbAsENERJ2WOMbklkHR+OuMvtJf3tpm/iVrNAlY9eM5AMDS8T0woXe4dO79nZec6pq5XFCOf++6DJ2h4cX1NFV6nM22HWdTWlkj/UyDYwKdarNMJsOwbuYq0OGMEmw8fg2/nM2z2bdK/P6BT49KwSdCrUK45fP6dH8mrpaYBx7vfmoClJ5y6AwmXC2pQkZhBbaeywMAfH5/ErY/MR6H/zpJ6rKqK7m7OQRlFFViwxH7g5zbG8MOERF1WunSruDmHcH9vcyjM7TNrOwcu1KCbE011F6euH9sAm7sG4F/3D0YAHC1pArHndgO4c73D+DVH8/h3e2XGrzu/k+OYPo7u3HAajFEsaoTH+qLQB+l0+1+fHJvm9cf7Um36YYqLK/BtdIqbE8tkI5FqL2ksCOO91k8NgExwT7oEWbuojqXq8WBy0UQBCApPhjXdw9FfKgvQvxUDtuydEJ3hPia2/7ruTz8dCqnw8fvMOwQEVGnlV5kG3bEPaTKqs1Vk3kfHcIpS4BwxhbL9O1JfSLgpfCATCbDrYO74FbLNO+tZ/MafYY4sPnHUzkOrzGZBBxKN28HYb0In1jp6d/FuS4sUf8uAXj51n64sW8EAPNAYzHAeFrW6fmuzsrGXQN9bELL2F5hWHZjLwCQuqLOZmulwdnOtsnfS4GnpyUCAA5cLsaSz47hoOVn7SgMO0RE1GmJM41iLZtjqr3NYUdbZcD9nxzBzgsFuHfdIaeft82yEvHkfpE2x4dbplg3Nr3beuuF8gaqS9aL+lnXPM5bNtbsE+XvVHut3ZMch3//abi0lQQAeCs8MN7SFWc9JufV2/ojNsQHAyzr4vSK8MN7c4fCS2Ee3NzXEnbOZGulLrDekc63SVzwUFS3u669MewQEVGnpDMYpWnUMZZZP7XdWHpcKzWPQSkst79eTF3VeiMyLJUicQyMKNHyF/2FvPJ691mz3nG9pLLG4b5Tp67VVpus17YRBw/3sSzU1xwLRsdL3w+KCcDEPuE25x+d1BNzkroBAIbGBmHrsrH434Oj4aOsnaDd1zLD61yOFqmWClHvCOfDjrgzu8hgMjXth2hlnHpORESdUnZpNQTBXL0Q14sRu7GaM2bnUkE5BAEI8FZIzxP1Cjf/RX+ttAraar30PnVZV2x0BhMyiioQqfbCrNX7cKmgHB5yGZ6emog8be3WFhfzynExr8xSRTGHqcRmVHZE/bsE4JslycgqrsL1PUIQ5qeCSRDw+s+pKKs24IZE2/DT006I6WOp7IiBUSYDekbUn2ruSIS/l81rcR+tjsKwQ0REnZIYLGKCvaXF98RVjgu0tn+5Gk0CPOzsMWXtkmWwc49wv3qL+QX4KBCp9kKuthoX88owrFv9NXdOZJXij/8+aHPsqyNZ8JTLpHEvBpOANTsvSVs1AECV3ogb/76r9r28ze/VEsO6BWNYt9rXc5K6YdaQrtBW6xHhxLPVXgrEBvtIn3G3YB+byk9j6u7nlaft2LDDbiwiIuqUxPE6MVYL1yVYBipn16kkWHcvOSKtDBxmv4LRy9KVdS7H/mrKX9jZ7fv9nZelWVnJCSHwVXqgoEyHqyVVCPZV1pteHqFW4Z6R3RpcObm5vJUeTgUdkdiVBTg/Dd7a7Otipe9zO7iyw7BDRESdUlaJWNmpDTshfqp6XVAAkFXceNi51MA2CADQ39K1c/Jqqd3z1gsZiuv9WOsTpcZ4qy6khaPj8c7dQxDsq4TKU45fHxuLg3+ZhCem9K53b0cQZ2QBwJBY51ZztvbKzP744J5hABh2iIiImkQQBBSV63Ap39ztFFNn5o+9WUOPf5WCcp3jcTyCIODYlRKH9wO1f+Efv1Jq93yBZcr5n8d3x9Lx3eudjw/1wYJR8UgI9cWjk3rigXHdERvigy2PjsGvj41Dj/Dmj9NpC32irMNOYJPv95DLpNle+WU6aTXmjsAxO0RE1KlsO5+PhR8fkV7XnTnVI8wPe9PMC/UF+ihQWqlHtqYa3x2/hrkju8Gek1c1yNFUw1fp4XAPLPEv/Iv55dBU6RHgbTtIuaDMHHbG9QqzG6ziQn0xrFsQtj0x3uZ4uH/Lxue0Fet1dRKbOTsszE8Fucw8VqmwQtdhPysrO0RE1KmsP1y7BYGnXCZ1L4liQ3yl7/c+fQPG9DRvX3DMakfvuracMS8mOD4xXFprpq5QP5W0foy9rixxEG642gtdgrzrnY+zaldnEBngha8fSMaPD4+B0rN5ccHTQy516eVpdI1c3XZY2SEiok6lm1W3VaifCp4etn8R3z0iBmeyNbhpYBR8VZ64b0wCdl8sxNErjsPOTss2CpMtKxA70ivCH1eKK7EztQApV0rRPdwP0wdEoVxnQGWNeS+scH/zVO+6ogPrByBXJy6m2BJfLkpGkI8Sau+OixwMO0RE1KlUW22w+crM/vXO+6o88dadg6XXg2MCIZMBmUWVKCzXoarGCC+Fh1RxKK6owVnLYn7Xd6+/k7e1yADzPf/Zky4de+nWfgiy7GPlp/KEr8r2r9aHbuiBaf2jGp367q7iQju+osWwQ0REHWL1jjRczCvH/90+sEndJGIFZfm0RExqpBIDmNet6Rnuhwt55dh9sQDLvjwBuQxIe3U65HIZ9l8yj+/pHeFvdxaVtbqL5QHAiu/PSN+HW93/1p2DcCZbi2WTetVbd4baF8MOERG1O53BiNe2mPdqSu4egjuHxzh9b6XOHHZ8lPbH1tgzrFsQLuSV4+ujVwEAJgHILK5EoLcC//jtgtSOxkQENDzANlxdG3ZmDe2KWUOdbiK1IQ5QJiKidvXGz6no/ewW6fV2y+abzqrUm8OOdxNW9BWnjYuztADz/lSfH7qCC3nlCPdXYaHVnlKONLYoX1RA5xuX83vAyg4REbWrf21Ps3m97Xw+qmqM8HayUlNVY57W3dTKTl1nrmmk6eLzro+rt16PPY1t49CU/aOo/bCyQ0RE7aaypv76MzqDyWYX8MafIVZ2nA87CaG+9dbFOXVNY3cV5oZYh51YO/c0ZWdwaj8MO0RE1G5Sc+3vK3W8gWnhdVVZwo5vE7qxZDIZ+tTZSfxIZom0y7i94GKP9fTpXnaCjaPVl6ljdWjY2bVrF26++WZER0dDJpPhu+++szkvk8nsfr3++uvSNXFxcfXOr1q1qp1/EiIiasyFvDLctnqfzbEJvcMAON6CwR6xstOUbiygftWlxmCCpkoPAIixswigPdYbdE7rH4mVswYgyKe2YtSlE66l83vQoWN2KioqMGjQICxYsACzZs2qdz4nJ8fm9U8//YSFCxfi9ttvtzn+0ksv4f7775de+/szWRMRuZrPDmRK30/pF4G7r4uFr9IT21ML8MvZXJy8WoqBXQMbfU6FpSusKd1YQO2u5QBwy6Bo/O9ENgBzaAr2rb95qCMfzR+Og5eLMXNIF3jIZRAE4C8bTwFAm+xWTi3XoWFn2rRpmDZtmsPzkZGRNq+///57TJgwAQkJCTbH/f39611LRESuJbO4Uvr+gXHdMSQ2CDqDEb0j/JGaV4aHvjiOHU+MbzQwVLVCZWf+qDgcTC9CnlaH2GCfJoWUGxIjcENi7fo+dw7vimq9EaN6NLwgIXWcTjNmJy8vD5s3b8bChQvrnVu1ahVCQkIwZMgQvP766zAYHO9sS0REHSO7tAoA8OnC66Sp4CpPD3y1OBkKDxkyiyqRWVTZ0CNQYzDBYNk926cJY3YA28pOl0BvzLs+DgDQs4WDij095FgwOp7jdVxYp5l6/vHHH8Pf379ed9fDDz+MoUOHIjg4GPv27cPy5cuRk5ODt956y+GzdDoddLraDcm0Wm2btZuIqDM7k63By5vO4skpiXanbztLEARcLTGHna5BtoOBA3wUGBIbhEPpxdh7qbDB7QXEqg7Q9MqO2kuB527qiwqdARFqLywak4AwPxUrMr8DnSbsfPTRR5gzZw68vGzXOHjsscek7wcOHAilUonFixdj5cqVUKnsL/u9cuVKvPjii23aXiIiV2MyCXj+f2fQO9Ifc0d2c+qeB/57FFnFVbh9zT5krJrR7PcuqdRLA4ujA+uvVXN99xAcSi/GvrQizEly3LZKvblyr/CQQeHR9M4J64UDPT3k+EMTVm6mzqtTdGPt3r0bqampuO+++xq9NikpCQaDARkZGQ6vWb58OTQajfSVlZXViq0lInJNP5/JxacHMvHsd6edvueapRrTUlmW8ToRahVUnvUrMknx5q0aUrJKG3xOhWWrCG9F06o69PvWKSo7H374IYYNG4ZBgwY1em1KSgrkcjnCw8MdXqNSqRxWfYiI3JX1wn2CIDg1KNdb4YEKq66j5nLUhSXq10UNALhWWoXiihqHs6NqByd3ir++yEV06P8t5eXlSEurXTY8PT0dKSkpCA4ORmxsLADzeJoNGzbgzTffrHf//v37cfDgQUyYMAH+/v7Yv38/li1bhrlz5yIoqPl9y0RE7sh6NpTOYIKXE9URb2VrhR3ze3d1sJ6N2kuB+FBfpBdW4NQ1Dcb1CrN7nbgCs4+KlR1yXod2Yx05cgRDhgzBkCFDAJjH3wwZMgQrVqyQrlm/fj0EQcDs2bPr3a9SqbB+/XqMGzcO/fr1w6uvvoply5bhgw8+aLefgYios8gorJC+L9c5N2vVOhCZLLOgmkOs7MQ4qOwAQL9oc3XndANbR4ibgDZ1cDL9vnVoZWf8+PEQhIb/8CxatAiLFi2ye27o0KE4cOBAWzSNiMitaCr1uJhfLr1+d3sa7hnZDQlhDW9cqfKs/TdxcWUNQv1qhwDoDEYoPeROdYc1VtkBgIFdA7DpZA62ns3Dn8d3t/tcqRtLwW4scl6nGKBMREQt88TXJ1BjMEmv1+7NwMS3djZ6n/VU73xt7ZIdpZU1SF65DYs+PerU+zc2ZgcAbhnUBd4KD6RklWLTyRy715RXsxuLmo5hh4jIzdUYTNh6Nq/ecUEAdl0ogM7geExOWXVtd9e5HC0OZxQDAH44mYPiihpsPZvXaIXedo0dx5WdyAAvzEkyj9fcd6nI7jWFFebAZV1hImoMww4RkZsrKDcHBIWHTBoXI/rTR4fw9q8X7d5nMgkor6kNO49vOIE/vLcfp65qUGV1XFvd8PifoooaVOmNkMmAKDtr7FiLtmyk6WhMkVhdCvNn2CHnMewQEbm5PG01ACDc3wt+qvpjXdbsuGT3vooaA+wVbS4XliPPqktLfL4jYlUnUu1ld40da2L7yqv1ds+LwS2MlR1qAoYdIiI3ly+GHbXKbtgBgJKKGqTll+FKUSUyi8yztqy7sBaMql15+IcTOfhob7r0urGwI84Ca6gLS+TnZQk7Dio7BWWs7FDTcTg7EZGbE6swEf5eUHrW/zeuXAYs/u9RHEo3j8dResixes5QxASbBxMH+yqx4ua+MAkC1u3LwK/nbMf/5GoaDjviOJ+BXQMbbasYxsocdI0VMuxQM7CyQ0Tkhqr1Ruy5WIgag0mqvESoVfC1U9kxCZCCDgDUGE146puT0Fq6kvwt1ZYQB6sa55fp7B4XHbQ8+7r44EbbLVZ2KmoaruyEM+xQE7CyQ0Tkhp7//gy+PJKFxeMSUFReAwAIV3tBU2V/LExdxRU1uJhnXpdHDDvBfvbDTkOVncJyHdIs6/tcF9d42PGXxuzUDztVNUaUWbq3WNmhpmBlh4jIDX15xLzB8fs7L1tVdrzga7Wn1IJR8ejfRW33fgA4dqUEAOCvUgAAQnxtA8atg6MBNDxm54RlY8+e4X4IclAZsmY9Zsd6SrsgCHhl81kA5oUOHY09IrKHYYeIyM1Zd2OpFLW/9h+6oQceu7GX9Hpa/0i8dvtATOsfCaA27IgBJNSqsjNrSBfcNNAcdq42sDO6uGpzYpTjUGVN7GbTGwXorBZBPJujxWcHrwAAPOQyp1ZtJhIxGhMRuTmxGykhzE+qtACA2luBGxIjsPbeEdh+Ph/PTEuEj9ITV0sq8ROAywXmWVRil1GI1XTv6EBvqSp0PleLsmo9/L0U9d77Ql4ZAHNlxxnWladynUHamyvNaquLGQOinHoWkYiVHSIiNxToUxs8TALQv4saXQK9oTfWdg15yM3VkQm9w/HSrf3hYwka3esEk+gA80KAwVbdUMG+SkQFeCM22AcmARj2yq84bqkEWRNDSq8I58KOh1wGX8smn9bjdtIt09dnDo7Ga3cMdOpZRCKGHSIiN2Qw2q4GOLWfuWvK3tTzunqG+9u8Flc1VnvVVl3EisuwbkEAzFtS/Gd37do73x67ine3p0mDnHvUeWZD7K21I4adxCg1u7CoyRh2iIjcTI3BVG9RvplDugAA5iZ1Q58oNZ6Y3MverQCAhDBfyK3yRFSAOexYh4wRceaQM7FPuHSspNI868toEvDYVyfw+s+pqNIbofCQoVuI4w1A6xIHH//tx3PSvl1i2IkP9XX6OUQihh0iok7uWmmVtOqxIAjYfbFAOhfgrcBH84dLu40H+Cjw0yNj8OANPR0+z0vhgdjg2nDSJbB25ePdT03AN0uS0TPCXKmZMSAKdw7vCgAwmMzVpLqzs4Z3C4bCw/m/bvwsY3/2XSrCmh2XIAgC0i3jhxIYdqgZGHaIiDoxo0nAqFXbMO71HSjXGbDldC4WfnwEgDnopKy4ETckRjT5uT2sxu1EBNQOTI4J9sGwbrXr5chkMtw8yDwrS2tZw+daqe3srFssU9Sd5WFVVTp5VYPC8hqU6QyQyYDYJlSIiEQMO0REnVRhuQ4/n8mVXl8rqcKGo1el10E+imaPbxHH2IT5qxrdvDPA21yJERcsvFpSaXNenMrurPO5ZdL3uZpq/HgqB4B5b63G2kJkD6eeExF1Urf+a69NFaWoXGfT/WSys2O5s8TZU9ZdWI6ovWzDzjXLujuJkf54885BCPRpfDFBR87maPH8/84AAOJDnZvRRVQXKztERJ1U3e6ivLJqmKxWHc6qU2Fpiin9InHHsK54dJLjsT0isbJTWWOE3miS2jWlXyT6RQc0+b3/cfcQeCnq//XE8TrUXAw7RESdkMlO2SZPq7PZ+0poQWXHV+WJN/4wCON7hzd6rdq7dk0fTZVeWlG5a1DjVSF7buwbgXMvTa13nDOxqLkYdoiIOiFxmre1PG21NEgYAF69rX+7tMVDLpM28Cyt1EsrL3dpZtgBzAOf6+5/xbBDzcUxO0REnVBBua7esbV7M6Tv375rsLS2TntQeytQpjNgR2o+rpVWwVvhgYFdA1v0zK+XJGPPxUK8svkcAIYdaj6GHSKiTqigrH7YsRauVjV4vrUFeCtwrbQKH+4xr6I8fUBUi3cmT4xUIzFSjehAb5RV6xETzGnn1DwMO0REnURVjREf7LoMkyDgH79dbPDaAO/6m3K2JfH9cjTmBQVnDW29qtJ0bvxJLcSwQ0TUSby06Qy+OJTl1LXtHXbU3rV/nfgoPTAiLriBq4naFwcoExF1Ej+dzq137O4RMdj7zA147qa+NsfVHVTZAYDkhBCnNhwlai/8v5GIqJPQG0z1jslk5oX/Fo6Ox5DYQOm4n7J9C/fWU9Rv7Nv07SmI2hK7sYiIOoHKGgMq9cZ6xwfHBErfWw8Ilsubt01Ec00fEIWdT45Ham4ZJvVh2CHXwrBDRNQJnMspq7dI4Gt3DMQdQ7tKr1s6+6mluoX4olsIp4eT62E3FhFRJ3Axr8zmtZdCjjuHx9hUcPp3afrWDES/B6zsEBF1AumF5lWJ+3dRw2AUsOLmvvWuuW9MPPK11ZjEMTNENhh2iIg6gcuWsHPn8Bj8KTnO7jUqTw+8eGv7bBFB1JmwG4uIqBMQKzvcMoGo6Rh2iIhcnNEkILOIYYeouRh2iIhc3LWSKuiNApSeckQHNH8ncaLfK4YdIiIXd7WkEgAQE+Td7uvnELkDhh0iIhdXWFEDAAj1a9+dzIncBcMOEVE7K6vWI6u40unri8t1AIAQP2VbNYnIrXVo2Nm1axduvvlmREdHQyaT4bvvvrM5P3/+fMhkMpuvqVOn2lxTXFyMOXPmQK1WIzAwEAsXLkR5eXk7/hRERE0z9z8HMea17bhc4NzvqmJLZSfEl5Udoubo0LBTUVGBQYMG4d1333V4zdSpU5GTkyN9ffHFFzbn58yZgzNnzmDr1q3YtGkTdu3ahUWLFrV104mImu3EVQ0AYP3hLKeuF7uxgn1Z2SFqjg5dVHDatGmYNm1ag9eoVCpERkbaPXfu3Dls2bIFhw8fxvDhwwEA//znPzF9+nS88cYbiI6ObvU2ExG1hN5Yu3N5am5ZA1fWKi63VHbYjUXULC4/ZmfHjh0IDw9H7969sWTJEhQVFUnn9u/fj8DAQCnoAMCkSZMgl8tx8ODBjmguEVGDSiv10vfncrQQ6u7uaQe7sYhaxqW3i5g6dSpmzZqF+Ph4XLp0CX/5y18wbdo07N+/Hx4eHsjNzUV4eLjNPZ6enggODkZubq7D5+p0Ouh0Oum1Vqtts5+BiMiapqpG+j6/TIcz2dpGN/AsqjD/vmI3FlHzuHRl5+6778Ytt9yCAQMGYObMmdi0aRMOHz6MHTt2tOi5K1euREBAgPQVExPTOg0mIpdUrTdixju7seS/Rzu6KTaVHQD4dH9mo/cUVbAbi6glXDrs1JWQkIDQ0FCkpaUBACIjI5Gfn29zjcFgQHFxscNxPgCwfPlyaDQa6Ssry7lBgkTU+Ry/UoK//XgOZ7K1+Ol0Lkoqahq/qQ2V1Ak7/zuRDZPJcVeWwWiSAlIIKztEzdKpws7Vq1dRVFSEqKgoAEBycjJKS0tx9Gjtv9a2bdsGk8mEpKQkh89RqVRQq9U2X0TkfgRBwG2r9+ETq+rJ6WxNB7YIKK00h63khBAAQJXeiLJqg8PrxXAkkwGBPgw7RM3RoWGnvLwcKSkpSElJAQCkp6cjJSUFV65cQXl5OZ588kkcOHAAGRkZ+O2333DrrbeiR48emDJlCgCgT58+mDp1Ku6//34cOnQIe/fuxYMPPoi7776bM7GICJoqfb1jp6+1fIye0STYzKpqCrFN4WoVfJQeAICSytpqU3FFDY5dKZEGLm89mwcA6BbsAw9uFUHULB0ado4cOYIhQ4ZgyJAhAIDHHnsMQ4YMwYoVK+Dh4YGTJ0/illtuQa9evbBw4UIMGzYMu3fvhkpVOyPhs88+Q2JiIiZOnIjp06dj9OjR+OCDDzrqRyIiF5JVXFXv2OlrLavslFXrMXLlb5jzn4MNdj/VZTCacKmgXAo2QT5KBFkqNeKxXRcKMHLlb5i1eh9+PJULQRDw792XAQD3JMe1qN1Ev2cdOhtr/PjxDU67/Pnnnxt9RnBwMD7//PPWbBYRuQlxA01r53JaVtk5m61FQZkOBWU67E4rxLheYU7d9/6uy3j951Sovcy/dgO8FQj0UeBaaZU0JufnM7moMZgrRgfTizAkNhDphRXwkMtw9whOpCBqrk41ZoeIqCmulpgrOx5yGZ6Y3AsAkKetbtEzs0pqq0Uf7Ul3+r7jV0oAAFrL+JxAH0W9yo7WauzOJ/szcf2qbQDMu537qlx6pRAil8awQ0RuS6zsLB6bgHtHxQMAKmqMqNA5HhDcGOsNPHdeKEBavnOrIF8rtQ1ZQT5KBPooANQOQi6rrj/GCADiQn2b01QismDYISK3JVZhugb5wFflCV/LgOD8Ml1DtzXyTHPYEccK/3NbmlOrIF+z3Ce2ISbYR6rsiDO0HM3Kigth2CFqCYYdInJb1yxhp0uQNwAgXO0FAMhvQVeWWNmZd30cZDLg+5RsbDh6tcF7yqr1UhfV9w+Oxr//NBxDYwMRJFV2aqTr7IkL8Wl2e4mIYYeI3Fi5pbsq0NscKsL8zDM5W1TZsczwunVwFzw60TwO6PODVxxeX6034plvTgEwD0ruEe6HG/tGQCaTSevm1HZjmds7a0gXeFpNM+/Gyg5RizDsEJHbqqwxhwdvS9dRmNocdgqaGXY0lXrklZmrQjFB3rhzRFcAwMmrpVJXVF0f7knH5lM5AICoAC+bc0G+5hBWtxvroYk9kfrKNOm67mF+zWovEZlxeD8Rua3KGiMAwFthDjvh/i2r7Px792UIAtA7wh/BvkrIZDL0ivDDhbxy7EkrxE0D6y9mujetUPo+o6jC5pxY2Skqr4HRJEiVKH8vT3jIZdj00GhoqvSIZTcWUYuwskNEbslkEqCzrFkjrlQc7m8Zs1PW9DE7OoMRH+/LAAAsu7EXZDJzN9P13UMBAMcyS+3el1FYG3AWWGaEiYItYed8bhnWH67tCvO3rMXTv0sARvUIbXJbicgWww4RuaUqvVH63kdpDg9hlspOc9baOXi5GGU6A8L8VZjcN0I6Hhtsrrrk2QlQuZpqZGvMx1+/YyCWjO9uc753pD96hJu7qP668TQAQOUph8rTo8ntIyLHGHaIyC2JXViAOUAAQJ8ofwDA0cwSVFmdb8xbv6TiTx8dAgBMTAyH3GrwcLg4Dkhbv2vsjGXT0cRIf/xheAz8vRQ2570UHvjfg6NsjtW9hohajmGHiNxSldV4HTGc9I1So2uQN6r1Juy8UOD0szamXJO+n5AYbnMuwjKd3V5lp6jCPPA4ss7AZGs+Sk8M6hogvRa3kyCi1sOwQ0RuSezGEsfrAIBMJsOUfpEAgJd+OIM71uzDhbzGV0A2WTY4HxwTiIl1wk64VddY3cUFNZYp5eLUd0eGdQuWvvdv5FoiajqGHSJyS+K0cy+F7fiXEXFBAIBsTTWOZJbgWctYmYZoLYv9vXnnIHh62P7aFAc9V+tNKKuzDUVplbmyI866ciS5e4j0vZcnfy0TtTb+qSIityR2Y1lXdoD6a9bUDSh1GU2CtP5NgJ2qi7fSQ+p6qrsys6bKHJLUjVRrxveu3Tn9YHpxg9cSUdMx7BCRW7LXjQWg3po1dRf6q8t6Cwe1g8HDtdtQ2A5SLnWyG0vhIccfk2IBAA+M697gtUTUdBwJR0RuSVpQsE7YqTut21vR8DRvsTrjrfCA0kEXU4RahbT88nqDlMV7xd3NG/LKrf0xuW8EhscFN3otETUNww4RuaWqOqsnO6J1sPmmSAws9rqwRBGWcTt5dSo7TQk7crkM43uHN3odETUdu7GIyO1U1hikqeXigoLWRibUVk/E8TiOaKscj9cRiXtuOerGauheImp7DDtE5Daq9UZ8c/QqFq47Im2+WbcbCwDeunMwEiPNCwyWNzJAuUmVnTrdWOIGnwHeDc/GIqK2xbBDRG7jra0X8PiGE9h/uUg6Zq8bKzrQG2/8YRAA2wHI9jgzoypcquzUhh2jSYDWUjVyphuLiNoOww4RuY3vjl+rd6zubCyRuNlmY91YTlV2xNlYZTo8991p3LFmH4rKa7u02I1F1LE4QJmI3IZKUf/fb/a6sYDaPagqa4wwGE31FgsUNaUb62pJFT49kAkA+PlsHgDAV+kBhYNnE1H74J9AInIbSjuhou4KyiI/Ve2/9Roat+NM2BG7sYym2u0ijl8pAQAE+XK8DlFHY9ghIrdhr4LiaEyO0lMu7YbeUFdWiWUzT7W340K4l8Kj3gae3x4zd6lN6x/ZcKOJqM0x7BCR27AXWgrKdHauNBO7shoKO6mWjULrbjNRl7iKsjWVp5wrIhO5AIYdInILgiCgsLx+sJk5uIvDe9TSIGX71R9ttR7phRUAgP5dAhp8/5gg73rH+karEeKnavA+Imp7DDtE5BYqaozQGUw2x359bByu7xHq8B6/RmZknc3WAgC6BHojuJGxN/YqOImR6gbvIaL2wbBDRG6hqE5V5/ahXdEjvOGuJ3H6uaMtI05f0wAA+ndpPLQkJYTgb7cNsNlYtG+Uf6P3EVHb49RzInILRRXiasUKvHRrP0zsE9HoPdEB5q6njKJKu+ePXykFAAxopAtL9MekWIzpGYoxr20HAPRmZYfIJTDsEJFbKCo3h524EB/c2sA4HWu9LVtGXLQMQrYmCAIOphcDAK6LD3G6HRFWA5V7R7CyQ+QKGHaIqNO7VlqFU1dLAdiGjcb0tISRC3bCzuXCChSW66D0lGNQjHOVHcA8pX3TQ6NhEgQEcJsIIpfAsENEnVpRuQ7jX98OvdG8oF+/aOeDiVh5ySiqhM5ghMqzdgHCQ5aqzpCYQJvjzmhs5hYRtS8OUCaiTu18bpkUdABgQFfnx8lEqFXw9/KE0STgckGFzbnUXHO1Z3BMYKu0k4g6DsMOEXUqW07n4I41+5CWXw6g/rTx/k2o7MhkMqm6U7crK7PIHH7iQn1b0lwicgEMO0TUqfxl42kcySzBpLd2QlutR7FlFpbI3krGDXE0bifTMkOrW4hPC1pLRK6AYYeIHLLe2NJVKDxk0vfDX/7VJqSsmjWgyc/rFWFei+dCXrl0zGA0IavEHHbiQljZIersGHaIyK51e9PR7/ktOHC5qKObYiPYt3b7hRqjCbsuFgAAFo9LwN3XxTb5eWI31tazeTiaad6pPEdTDb1RgNJTjsgmVoqIyPVwNhYRQWcw4vY1+9A3So3X7hgEAHjhh7MAgH9uu4iRCc6vM9PWKnTmMTpBPgqUVOqlgcUhjWzn4EhPq7Vwbl+zDzcNjIKn3Fw96hbsA7lc5uhWIuokOrSys2vXLtx8882Ijo6GTCbDd999J53T6/V4+umnMWDAAPj6+iI6Ohp/+tOfkJ2dbfOMuLg4yGQym69Vq1a1809C1LmdvKrB6WtafHXkKqr1RpvtEyL8XauyUW4JOz3rLNhnXfFpilA/JcL9a+/ddDIH36WYf890YxcWkVvo0LBTUVGBQYMG4d133613rrKyEseOHcNzzz2HY8eO4dtvv0VqaipuueWWete+9NJLyMnJkb4eeuih9mg+kdvwsKpepBdW4GhGifTaV9UxBeAagwm3rd6Le9cegiDUjh0Sw4441kbU3MqOTCbDu3OGItSv/v1xHJxM5BY6tBtr2rRpmDZtmt1zAQEB2Lp1q82xf/3rX7juuutw5coVxMbW9s37+/sjMjKyTdtK5M6qaozS9xfyymwG/Yrhor2l5pZJe1Ot25eBPwyPgdJDjhrLzua96lR2gpoZdgBgRFww/vXHobj7gwM2x7tx2jmRW+hUA5Q1Gg1kMhkCAwNtjq9atQohISEYMmQIXn/9dRgMHfPLmaizqrQKO2t2XMKBy8XS644KO5cLa2dHvfjDWTz8xXFpvA6AejuaN7eyIxreLQiT+9puHsrKDpF76DQDlKurq/H0009j9uzZUKtrV0h9+OGHMXToUAQHB2Pfvn1Yvnw5cnJy8NZbbzl8lk6ng06nk15rtdo2bTuRq6usqQ0R53Nt15spr+6YsCMuGijadj4faQXmY14KOWKDbYNIcAvDjqeHHB/8aTge+yoF3x67BoDTzoncRacIO3q9HnfeeScEQcCaNWtszj322GPS9wMHDoRSqcTixYuxcuVKqFT2ByyuXLkSL774Ypu2magzse7GqqujKjuXLMFm0dgE7LpQgPO5ZVh/KAsA4KdS2Gz4OapHSKuNLbLeBysqwLUGZxNR87h8N5YYdDIzM7F161abqo49SUlJMBgMyMjIcHjN8uXLodFopK+srKxWbjVR51LZQNip6Kiwk2+eUp7cPQR/TDKP0fvxVA4AwE/lAYWHHM/O6IN5yd3wnz+NaLX3jVDX/iPJ08Plf0USkRNcurIjBp2LFy9i+/btCAlpfK2PlJQUyOVyhIeHO7xGpVI5rPoQ/R5V6c1h587hXfHVkas258o6IOwYTQLSC81hp0eYH+It3UliO/28zL+67huT0OrvvWB0PI5mluCmgVGt/mwi6hgdGnbKy8uRlpYmvU5PT0dKSgqCg4MRFRWFO+64A8eOHcOmTZtgNBqRm5sLAAgODoZSqcT+/ftx8OBBTJgwAf7+/ti/fz+WLVuGuXPnIigoqKN+LKJORxyz46P0RJdAb1wrrZLOdcSYnasllagxmqDylCM60BtyGWza5atsu19dai8FPl2Y1GbPJ6L216wabVVVFSorK6XXmZmZePvtt/HLL7806TlHjhzBkCFDMGTIEADm8TdDhgzBihUrcO3aNfzvf//D1atXMXjwYERFRUlf+/btA2Cu0Kxfvx7jxo1Dv3798Oqrr2LZsmX44IMPmvNjEf1uid1Y3koPvDd3GCLUKjx3U18A5mpKe++RJY7XiQ/1hYfcvFhocvfayq6/l0sXpYnIxTTrN8att96KWbNm4YEHHkBpaSmSkpKgUChQWFiIt956C0uWLHHqOePHj7dZLKyuhs4BwNChQ3HgwIEGryGixokDlH0UHhjQNQAH/zIJOoMRL28ybxlRrjMgwFvRbu0RZ2JZTy8f1SMEXx81d7F11EKHRNQ5Nauyc+zYMYwZMwYA8PXXXyMiIgKZmZn45JNP8M4777RqA4mo7VlXdkQqTw8oLQN022tGliAIKNcZpMHJ3cNqw8713UOl7/0YdoioCZr1G6OyshL+/ubVS3/55RfMmjULcrkcI0eORGZmZqs2kIjanhh2fOqMhfHz8kRxRU27zMjK0VRhyX+P4Wy2FjVG8yrJ3a0qOxFqL3QP88WlggqGHSJqkmZVdnr06IHvvvsOWVlZ+PnnnzF58mQAQH5+fqNTw4nI9VTpxQHKHjbHfVXm12XtMEj5L9+eQkpWqRR0gPr7X03sY17huGuQd5u3h4jcR7PCzooVK/DEE08gLi4OSUlJSE5OBmCu8oiDjYmo87DXjQWYF+8D2n6tnXM5WmxPLbA59odhXdG7zv5Xj07qiY8XXIe7RsSCiMhZzaoF33HHHRg9ejRycnIwaNAg6fjEiRNx2223tVrjiKh9SAOU64Qdf0t3kaZK36bvv/mkebHAqf0i8dzNfXHmmgaT+kRAJpPZXOej9MS4XmFt2hYicj/N7viOjIyst9P4dddd1+IGEVH70hmMKK00h5m6YSc+1BeHMopx7EoJbh4U3WZtyNNWAwD6d1GjS6A3ugSym4qIWk+zurEqKirw3HPP4frrr0ePHj2QkJBg80VEnYPeaMKs1fuQawkb3grbf/9MSDSvRL52bwayrRYabG3FFTUAgGBfrmxORK2vWZWd++67Dzt37sQ999yDqKioeqVmIuocfjyVgzPZWul13crO6J6hUHrIUWM04fpV25Cy4kYE+rRsd3F7iivFsNP6zyYialbY+emnn7B582aMGjWqtdtDRO3o430ZNq/rhh0/lSf+mBSLdZbrrpZUtU3YsVR2QvwYdoio9TWrGysoKAjBwcGt3RYiameZRZU2r+vOxgKAF27ph4RQ80acbTUrq7iclR0iajvNCjsvv/wyVqxYYbM/FhF1LoIg2Myy6hLo7XCDTXF7hoqa1g87OoNR2lk9hGGHiNpAs7qx3nzzTVy6dAkRERGIi4uDQmG7Z86xY8dapXFE1HYqa4wwWDb4PPSXifBWekAutz/+TuzeqtAZ650zmgR4OLjPGSUV5sDlIZdB7dV++28R0e9Hs8LOzJkzW7kZRNTeSi1VHYWHDGH+qgYnGojbM9Ttxvrm6FU89/1pvH/PMIzpabv+zY7UfPSK8Ee0g2nkOoMRj65PkTYYDfJROgxbREQt0eSwYzAYIJPJsGDBAnTt2rUt2kRE7UBjWVsnwFvR6IzK2m4s28rO4xtOAAD+9NEhHP7rJGir9EgI88PPZ3Kx+NOj6BLojb3P3GD3mXvTCvHT6VzpdbAvqzpE1DaaPGbH09MTr7/+OgyG9tkFmYjahjheR+3deMgQ98hyNEBZEIDbVu/FDW/uRFZxJf57wLwh8LUG1uap2yXGwclE1FaaNUD5hhtuwM6dO1u7LUTUjsSwE+hM2FE2PkA5q9gcbLaezcNZq7V7HCmxrK0jilR7NXoPEVFzNGvMzrRp0/DMM8/g1KlTGDZsGHx9fW3O33LLLa3SOCJqO9qq2m6sxvg4GLPjp/JEeZ1jL20669T7iwOTVZ5y3DOyG+6+jpt7ElHbaFbY+fOf/wwAeOutt+qdk8lkMBrrz9ggIteiaULY8bN0Y1XqjKgxmPCvbRcxPjEcaq/6YacuncEIlWf99XvEys59Y+Lx5JTEpjafiMhpzQo7JpOptdtBRO2sKWHHx9KNVa4zYN2+dLyzLQ3vbEtzapxNebUBKj9z2Hn95/P49tg1TEgMR3m1OSQFtcGKzERE1po1ZoeIWkdWcSWMlrVumqqkokbaZqE5mlbZMYedyhojUrJKpeNl1Xq713+1OBm+lrV5yqprKz+fH7yCHE01Pj94BYfSiwGgTbafICKy1qzKzksvvdTg+RUrVjSrMUS/J1vP5uH+T45g7shYvDJzQJPuzS6twk3/3AO5TIYdT46XwoizKnQGaZ0dZ2ZjiYsKlusM8FLUdknpjeagNqF3GF66tT9+PpOLksoajIgLgp+XJypqjFI3l7Zaj5LK2nAk7rTOKedE1NaaFXY2btxo81qv1yM9PR2enp7o3r07ww6RE/724zkAwH8PXGly2PnrxlNSVefHUzm4c3iM0/euP3QFyzeegmApKDlTWamt7BhQY7QNJzIZ8OG8EZDLZbhvTILNPXnQSZWdK0X2t5dhZYeI2lqzws7x48frHdNqtZg/fz5uu+22FjeK6PfAununaffpseNCgfT66yNXmxR2Nhy9KgUdAIgN9mn0HnFRwQt55biQV25zzk/paXflY3/L1g9iV1dWsf2wwzE7RNTWWm3MjlqtxosvvojnnnuutR5J5NbKdbVdOoLg/LidU9c0NmHl2JWSJo378bbqhrp3VBxGxAU1eo+4qKA9fl72/83kbzmeUVSB93dewm/n8wGg3j5awQw7RNTGmlXZcUSj0UCj0bTmI4ncktEkoFpfO6uxTGdwehPMk1fNf8Zu7BuB387lwWASUFSuQ7iTi/IVlusAAH+7bQD+mOTc2ja+DYwJ8ncQdsSur79vvYgqfe1yFON6hWGbJfjIZY7vJyJqLc36LfPOO+/YvBYEATk5Ofj0008xbdq0VmkYkTu7VmK7jUK+VteEsFMKABgaG4RTVzXI1VYjV1vtdNgpKDOHnSGxgU63V5x6bo+jwdFiiLEOOgAwvncYDlwuQmWNEYmRam7+SURtrllh5+9//7vNa7lcjrCwMMybNw/Lly9vlYYRubOzObbbKZzIKsXRzGJcLqzAkYwSfHZfks2sJ2upuWUAgP5d1IgM8EKutho5mmoMdGJfXoPRhGLLYn5h/iqn2+un8kSk2kuaQWXN30FI81PZHh/QJQC+Kg/cNDAaQ2ODcLWkEqN6hDrdBiKi5mpW2ElPT2/tdhD9rvx0Osfmtbh7uOjXc3m4aWC03XvF9XFC/VTSflJ5dkKIPcUVNRAEc/dRUwYGe8hl+OGh0dAbTfhkfyb+l3IN2RrzezrsxqpzfPn0RFzf3Rxugn2V6N8lwOn3JyJqiWYNUF6wYAHKysrqHa+oqMCCBQta3Cgid1ZVY8TWs3kAgG4h9mdCKTwc/9HUWmZxqb0ViAwwh50cjXNhJ9/ShRXip6o3ULgxYf4qRAd645lpiTZjfRyFHXWd42F+zleSiIhaU7PCzscff4yqqqp6x6uqqvDJJ5+0uFFE7iwlqxSVNUZEqr1wY58Iu9d4O+jCqtab96YCzGFCDDu5ToadAsvg5JYGj4QwPwDmNXam9Iu0e03dEBTKsENEHaRJ3VharRaCIEAQBJSVlcHLq3ZApNFoxI8//ojw8PBWbySRO7lUYF6npk+Uv8PKjhho6tJa1qyRyQBfpSeimhh2Ci2VndAmjNexZ2q/SKxfNBK9Ivwd7o/VLcRX+t5TLnNqWwoiorbQpLATGBgImUwGmUyGXr161Tsvk8nw4osvtlrjiNzR5YIKAObqSJ8otd1raoz2w464EKG/yryQnzhmx97AYXvEbqxQv5atbSOXyzAyIaTBa/pG1/5snh4yzroiog7TpLCzfft2CIKAG264Ad988w2Cg4Olc0qlEt26dUN0tP1BlURkdrnQXNnpHuaH3pH+dq/RGYx2j2stg5PFGVC1Y3aqIAgCZLKGA4W4inFMUOOrJreU9VR66zWFiIjaW5PCzrhx4wCYZ2PFxsY2+ouViOoTu7ESwnwdTtt23I1VOzgZACIslZ1qvQnaKgMCfBruKsq07E/lqPuMiMgdNWuAcrdu3bBnzx7MnTsX119/Pa5duwYA+PTTT7Fnz55WbSCRO6nWG3HVsqBgQpivw+schR1xnylxppOXwkMaM5OjrT9poK7MInMXmvV4mrZ008AoAMCgmMB2eT8iInuaFXa++eYbTJkyBd7e3jh27Bh0OvM4AI1Gg7/97W+t2kAid5KnrYYgAF4KuTQjavWcoQivM2BY56iyU2UZs2NVERKrO41NP6/WG5FjGdvTXpWdv80agGemJWL1nKHt8n5ERPY0K+y88soreO+99/Dvf/8bCkXtL91Ro0bh2LFjrdY4IncjLggY6K2UuoGnD4jCob9OwsLR8dJ1jsKOVNnxru2BFmdk5TUSdq6WVEIQAF+lB0IczKBqbWovBR4Y1x1dAr3b5f2IiOxpVthJTU3F2LFj6x0PCAhAaWlpS9tE5LbEsGNvGvZzN/XF7OtiADQ+9dx68K+zCwvWjtfx5Xg7IvpdaVbYiYyMRFpaWr3je/bsQUJCgtPP2bVrF26++WZER0dDJpPhu+++szkvCAJWrFiBqKgoeHt7Y9KkSbh48aLNNcXFxZgzZw7UajUCAwOxcOFClJeXN+fHImpzDYUdoHbDTXuVnU0ns/Hu9ksAbFcnlqafNxJ2zln24+oe7tfEVhMRdW7NCjv3338/HnnkERw8eBAymQzZ2dn47LPP8Pjjj2PJkiVOP6eiogKDBg3Cu+++a/f8a6+9hnfeeQfvvfceDh48CF9fX0yZMgXV1bW/1OfMmYMzZ85g69at2LRpE3bt2oVFixY158cianNS2HEwa0rpaf4jaa+y89hXtftnqb3rV3ayNQ0PUD6SWQIAGNqE3c6JiNxBszYCfeaZZ2AymTBx4kRUVlZi7NixUKlUePLJJ3Hfffc5/Zxp06Zh2rRpds8JgoC3334bzz77LG699VYAwCeffIKIiAh89913uPvuu3Hu3Dls2bIFhw8fxvDhwwEA//znPzF9+nS88cYbXPOHXE5jlR2lZU+sGqP9dXZE1pWfPpHmxfuOZpagWm+0u1u6ySTgqCXsDO8WXO88EZE7a1ZlRyaT4a9//SuKi4tx+vRpHDhwAAUFBQgICEB8fHzjD3BCeno6cnNzMWnSJOlYQEAAkpKSsH//fgDA/v37ERgYKAUdAJg0aRLkcjkOHjzYKu0gaqljV0rw4g9n8PnBK3htSyoAx2FHpTD/kdTZWYTPer+s67vXrl7cv4sa0QFeqKwxYvfFQrvPTc0rQ1m1AT5KD/SJsr+QIRGRu2pSZUen0+GFF17A1q1bpUrOzJkzsXbtWtx2223w8PDAsmXLWqVhubm5AICICNuNEiMiIqRzubm59fbi8vT0RHBwsHSNo59DnC4PmPf8Imors1bvq3es8cqObdiprDFIVaFvliRjSGyQdE4mk2FK/0is3ZuBLadzcWPf+puLfp+SDQBIig+GZwM7qhMRuaMm/dZbsWIF1qxZg7i4OKSnp+MPf/gDFi1ahL///e948803kZ6ejqeffrqt2tpqVq5ciYCAAOkrJiamo5tEbuR8rhYlFTUAAKNJsHuNw8qOp/3KTnapeZyan8oTw+x0Q0217Dz+67k86OsEJZ3BiK+OZAEAZl8X6+yPQUTkNpoUdjZs2IBPPvkEX3/9NX755RcYjUYYDAacOHECd999Nzw86o8VaK7ISPMv77y8PJvjeXl50rnIyEjk5+fbnDcYDCguLpausWf58uXQaDTSV1ZWVqu1m37fLuaVYerbu3HTP80riYsrFtcV6GCAssrT/GfIurJTUlGDBz83r18lrqlT1/C4YIT4KqGp0uPg5WKbcyeyNCiuqEGonwo3JIbbvZ+IyJ01KexcvXoVw4YNAwD0798fKpUKy5Yta5M1O+Lj4xEZGYnffvtNOqbVanHw4EEkJycDAJKTk1FaWoqjR49K12zbtg0mkwlJSUkOn61SqaBWq22+iFrDnjTzmJlrpVWoqjHiTLb9LlK1o24sO7Ox1u5Nx/ncMgC1M6/q8pDLpO6r387b/gMhLd+8FEO/aDW7sIjod6lJY3aMRiOUytqVVz09PeHn1/w1O8rLy23W60lPT0dKSgqCg4MRGxuLRx99FK+88gp69uyJ+Ph4PPfcc4iOjsbMmTMBAH369MHUqVNx//3347333oNer8eDDz6Iu+++mzOxqEPIrYL/mWwNzubYDzuNdmNZ7XqeadmpHADKLBuB2jMyIQTrD2chJavU5rgYdnpwfR0i+p1qUtgRBAHz58+HSmXex6e6uhoPPPAAfH1tNxX89ttvnXrekSNHMGHCBOn1Y489BgCYN28e1q1bh6eeegoVFRVYtGgRSktLMXr0aGzZsgVeXrX/uv3ss8/w4IMPYuLEiZDL5bj99tvxzjvvNOXHImo1+WW1a0ClZJVKlZ0ugd4oKNdJFRuHA5TtVHasx+DMu76bw/ce2DUAAHA2Wwu90QSFpYqTVsCwQ0S/b00KO/PmzbN5PXfu3Ba9+fjx4yEI9gdwAuZZJi+99BJeeuklh9cEBwfj888/b1E7iFqDwWiy2bLhlc3npO//9cch6Bnhj/7P/wyg8bBjvY5OvtY8c3DlrAG4bUhXh+8fF+ILfy9PlFUbkJpbhv5dzOHnEis7RPQ716Sws3bt2rZqB1GnZjQJmPHOHqTmldU7J5cBiZFqeCs98PKt/VBRY0Son8rOU6wGKFuHnTJz2GksrMjlMgzsGoC9aUU4eVWD/l0CUFljwLVS88rKPcIYdojo94mjFYlaQa622iboPDW1t/S9wkMOb6U5xNyTHIcHxnV3+Jy6lR1BEFBgCTvh/vYDkrWe4eYFA7NKzON88ixVIT+VJ4LaaadzIiJXw7BD1ApySm33pZrQu3aKd3ATQkbdRQXLdQZU6c2DlcP97c/EshZmCURi11dxha7JbSAicjcMO0StIKfOjuMRai+sXzQSCaG+ePMPg5x+Tu12EeaAI3Zh+as8pepQQ8TqT0G5+b6icvPihqzqENHvWbM2AiUiWzl1dhwP8lFgZEIItj0xvknPqVvZEbuwwpzowgKAcLW5+pOvNYevYstKziEMO0T0O8bKDlErELdzAIB7R8U1e6FNldXUc0EQkGcJLU6HHbGyYwlJRZaww24sIvo9Y2WHqBWIlZ0Xb+mHedfHNfs54mwskwAYTAKulpif2zXIx6n7xVBUVFEDvdHEyg4REVjZIWqSrOJKTPvHbnx99KrN8VzLmB1He1c5S5yNBZirOxmF5r21uoU4F3aCfZTwlJurSoXlOinssLJDRL9nDDtETfD0NydxLkeLJzacAAB8vC8D89cewjnL3lXRgd4ter512NEZTNJWEc6GHblcJq3hU1CmYzcWERHYjUXUJEczS6Tv/7P7ss0qyUDLKzsechm8FR6o0hvx+s+p0q7p3UJ8G7mzVrhahVxtNfK1OpQw7BARsbJD5CyjSbDZxuGNX1Jtzis95a0SKh6f3AsA8MWhK9KigHFOVnYA8z5cAHA4oxinrmkAMOwQ0e8bww5RI97dnoaXfjiLC3W2gqjWm2xeRwV4NXsWlrX7xiRgTM9Q6bXayxOBPs6HFXFBw/d3XZaOhfg6N5uLiMgdMewQNaDGYMLrP6fio73p+O1cXr3zg2MCpe9b2oVl7ZZB0dL3Q2KDmnTvpL4RNq97RfghKrD12kZE1Nkw7BA1oMiy3QIAXLbMjLJmXYGJDmjZ4GRr0wdEITkhBJP7RuC1OwY26d5gXyWm9Y+E0lOOTxdeh58fHQuFB/+oE9HvFwcoEzVAXJwPAC7mldc7P7pHKP65LQ0AENmKlR1flSe+WDSy2fe/M3sIKnSGJnV/ERG5K/5zj6gB1mEnNbes3vkBXQOk7/29FO3SJmcoPOQMOkREFgw7RA2wDjviflXWfJS1xVH2FBERuSb+eiZqQL5V2BEFeJsrOImR/gCAmYOjEeijwKyhXdu1bURE5ByO2SGyo6SiBkG+SpvKjuj/bh+IHE0Vpg+IAgD8/a7B0BsFm9WPiYjIdTDsENXx4Z50vLzpLN6+a7DdsBMX6oOp/SOl1zKZDErPlq+vQ0REbYP/FCWq4+VNZwEAj36ZgoLy+mGHC/QREXUuDDtEdcitijTZpVX1zgf5uM6sKyIiahzDDlEd8aG1m27maKqh8JDBw5KAgnwU8OS0KyKiToVjdojq8KuzXs7NA6PxzPRE/H3rBQzqGtgxjSIiomZj2CGqo1JnsHk9OykW4f5eWDmrads2EBGRa2DYIaqjwhJ27hzeFXNHdsNAVnOIiDo1hh2iOipqjACARWMT0CPcv4NbQ0RELcWRlkRWBEGQKju+Kv5bgIjIHTDsEFmpMZpgMAkAbPe9IiKizothh8hKhc4ofe+r9OjAlhARUWth2CGyInZhqTzlXE+HiMhN8Lc5kZWKGnPY8eN4HSIit8GwQ2RF7MbyUbELi4jIXTDsEFmRZmJxcDIRkdtg2CGyUlnDaedERO6Gv9GJABSW6/DI+uOosiwoyLBDROQ++BudCMC/d1/G3rQi6TWnnRMRuQ92Y9HvnskkYNOJHJtjXgqGHSIid+HyYScuLg4ymaze19KlSwEA48ePr3fugQce6OBWU2dyOluDa6VVAABPuQwAEBPk3ZFNIiKiVuTy3ViHDx+G0Vi7qu3p06dx44034g9/+IN07P7778dLL70kvfbx8WnXNlLb+/zgFXy45zI+nDcCcaG+rfrsywUVAICk+GB8NH8E9qQVYnSP0FZ9DyIi6jguH3bCwsJsXq9atQrdu3fHuHHjpGM+Pj6IjIxs76ZRO/pkfwYuFVRge2o+MvdVIkdThWem9UF8KwSfjCJz2OkW4gNflSem9OP/S0RE7sTlu7Gs1dTU4L///S8WLFgAmUwmHf/ss88QGhqK/v37Y/ny5aisrGzwOTqdDlqt1uaLXFeFzoALeWUAgLPZWqzbl4Gfz+Rhwhs78PhXJ1r8/CtF5v9fuoW0bsWIiIhcQ6cKO9999x1KS0sxf/586dgf//hH/Pe//8X27duxfPlyfPrpp5g7d26Dz1m5ciUCAgKkr5iYmDZuObXEyasaWDYix84LBTbnvj1+Ffll1dLrK0WV+D7lGkziDU7ILDaHnTiGHSIit+Ty3VjWPvzwQ0ybNg3R0dHSsUWLFknfDxgwAFFRUZg4cSIuXbqE7t27233O8uXL8dhjj0mvtVotA48LO3G1VPo+v0wHABjTMxSaKj1OXtVg69k8zEnqBgCY8c5ulOkMkMlkuGVQtL3H1ZNp1Y1FRETup9NUdjIzM/Hrr7/ivvvua/C6pKQkAEBaWprDa1QqFdRqtc0XuRajSYDJJODk1VIcvFxU73z3MD9M6x8FAPjlTB4AQBAElFm2e9hdpwLkSGllDQrLawAAsQw7RERuqdNUdtauXYvw8HDMmDGjwetSUlIAAFFRUe3QKmoLheU63PjWTpRU6h1e0yPcDwO6BAAAzuWYx1yJ08cBQG41pqshr24+BwDoGe4HtZeiuU0mIiIX1inCjslkwtq1azFv3jx4etY2+dKlS/j8888xffp0hISE4OTJk1i2bBnGjh2LgQMHdmCL3YsgCNhw5Cr6RKkxoGtAm7/f+ZyyBoMOYK7sJISZx9jkl+lQVq2XBjEDQLamytGtkqJyHTYcvQoA+NusAS1oMRERubJO0Y3166+/4sqVK1iwYIHNcaVSiV9//RWTJ09GYmIiHn/8cdx+++344YcfOqil7ml7aj6e+uYkbv7XHhiMpjZ/v7Jq+0FnkCVodQn0xtBugfD3UiDMXwXAvFZOam65dK04nbwhh9KLAQC9I/wxIi64pc0mIiIX1SkqO5MnT4Yg1J9dExMTg507d3ZAizqHrOJKfH30KiYkhmNwTGCzn7P9fO34l10XC3BDYkQrtM6xsmrzuJsJvcNQoTPiUEYxRvcIxfLpiTicXoy7RsRC5WnezqF7mC8KynS4VFBuW9kprYbeaILCw3GeP2gJO0kJDDpERO6sU1R2fm8EQcDZbC2q9cbGL3bg0wOZGPPadvzjt4v4m2VcSnPtu1Qofb/xeHaLnuUMraWyo/ZW4L17hmHphO54885B6BcdgPmj4uFttUlnQpgfAHNl53JBbWXHaBJwtaThriyxspMUH9LaPwIREbkQhh0X9NPpXEx/Zzce/uJ4s+4vLNfhhf+dkV5fLWl4kcWGnM3W4lJBbZdQphPdQy2ltVR2/L08EeyrxJNTEhGh9rJ7bYJlBeVLBeXIsCwO6GHZ3yotv9zuPQCgN5qkStCQ2MDWajoREbkghh0X9MGuywCAX87mNev+XE01jFaL6pVU6u12AzrjxR/MoSlCbR4bo6lqeOBwaxDH7Pg7MTuqd6Q/AODA5SKpbVP6mbvZzmZrpec9/tUJ7L5Y2x2XWVQJg0mAr9IDUQH2gxQREbkHhh0XJFYmmktr+Uu/S6B55+4qvREVNU3vEiuuqJHGtfzf7ebZbe0TdmorO41JjDSvkSTO3opUe2FobBCA2inpb/5yAd8cu4p7Pjwk3Sd2ecWH+dpsPUJERO6HYccFeVj95VtjaPrsJzGQRAZ4wVthHt9SaFl5uCmyLevWhPqp0CfKHCq0VfombcXQHE2p7IT5qxDqp5Rex4X6oK+lredyzWEnJatUOp9l2RpC7JrrbhnzQ0RE7othxwXVWE3vztNWN3ClfWLYCfBWINTfHAR2pxVi0SdHsOzLFJRW1jj1nFyN+b2jArwQ4G0OHiYBKK8xNLlNTSFWdtROVHaA2uoOYN7fSgxmmUWV0FbrbcYZjXltO/6y8RT+b8t5AEBCKMMOEZG7Y9hxQQVWVZjcFoadMD/zWJvXtpzHL2fzsPH4NWw5nevUc3Is7x0Z4AUvhQdUnub/XTSNLPjXUrVhx7kVjftE+Uvfj+kZhiBfJSItA5o3ncipt0Dh5wevSN+LCxMSEZH76hTr7PyeCIJgs4t3dmnjKwHXZVPZsYQdMUAAQFGFs5Ud83uLA3gDvBXIL9NBU6VHW2ybKggC/rktDaeuaQA4N2YHAO4aEYsLeeW4dXA0pg+IBGAOQLnaaqzbl+7wvu5hvhjVI7TlDSciIpfGsONiSir10Btrx8ScvKqBSRAwY0A0lJ7OFeLEsKP2Vth0iUnv0UjYqdYbUVJZgxxNbWUHsA07beFMthZvbb0gvXZmzA5g3ifr4wXX2RzrE6XG9tQCXMgzD0ReNqkXbhkcjWBfJfZcLMQNieE26/UQEZH7YthxMXXH6Hy4J91yXIcHxnV36hnWlR17ihsZs/PXjafxXco1qdvKurJj/fzW9rVlnyqRs5Ude8RxO6KkhGDEW9bkmTGQm8QSEf2ecMyOi8l3MGtq00nnVy62Djvi+jjWShsYcyMIAr45dhVGk4BKy3T1SLW39Dzr57cmk0nADydsf8aWhJ2+0bVhR+khb9F2GURE1LmxsuNiqiwznZQecpsuKHEKuTO0VmEnUu1f73xJA5WdK8X1V1sW1+sJ8Gm7sHOpoLzeWCJfZfP/94wP8cX0AZFIyy/HPclx8GrC50dERO6FYcfF6Czr6vTrosbxK6XS8Rqj82vbiGEk0EdhM1NJ5GjMTn5ZNR6qs0VFj3A/xATbVnZW/XQeE3qHS6sXO6usWo9XNp1DYpQ/7h0Vb3PuSGYJAPOg4UsFFegR7gd5CxZXlMtlWD1nWLPvJyIi98Gw42J0enPYCfJR2hw/kVWKd367iIdu6NHoir/W3Viednb9rjsVW/TRngycvKqRXstlwKsz+0vvZ11den/XJbw6cwC01XqH+1ZZq6wxYO5/DuKE5fk3JIajW4gvfjuXh3e3p0khb2r/SMxLjoMXBw8TEVEr4ZgdF1NtMI+TUdmZefXW1gs4cLm4wfsFQZA20hQrMXOSYgEAN/Y17xmlrdbDYGeWlvXg6NfvGIifHhmLpITaHcF7RtQuwHcupwwP/PcoRv/ftgY33BTb9MSGE1LQAYD/7DYPvH5501kcu1KKM5Z9rIbHBSNc7eX0GjtERESNYdhxMWJlx0vhgbfuHFQv9Jy4Wor8BhYaLNcZpE1AxbDz3E198d7coXjjjkEAAEGwP+6mQmcOSQ/d0AN/GB5Tr5vqpoHRePzGXgDM+07tvFAAvVHAz2caXqTwqyNZ+PFULhQeMjw4oQcA4Ldz5k1Oq/W1oWtQ1wCM5ro3RETUyhh2XIzOqrIza2hXnHlxis35VT+dx3V/+81mV3NrYohResqlQbleCg9M7R+FAB+FNMPJXldWuSXs9Ai3v4WCwkOOReMSUHcoTXphhd3rSypq8POZXLz960UAwGM39sb9YxIAANmaapRV62EwmcPOgC4B+HD+CCjsdLsRERG1BP9mcTHi2BWxouPpIcd7c4fWu67Cwf5Uja2xE+xrHgtkb38sZ7ZpUHl61Askp69p6l2nrdZj5uq9WPzpUeRoqiGTAX9K7oYAH4W0lcOZbC0Ky83tWHfvCGm1ZyIiotbEsONiqvWWyo7VYOCp/aPw8q39bK6rsqyBIxIEc6WnsbATaBn4XGxnRpa427hfI+vbWK9hAwAX88uldove3ZaGzKLaaewJob7wVZmf28vSPbb7YgEA8zR7MYQRERG1NoYdFyNWdrzqjNWJCvC2eV1pFXa+OpyFYa/8iqOZJTZr7NgTZFkrx97CgmI3VmOL+T1/cz/cPCgaO58cjxBfJYwmARfyymyu2XWx0OZ1/y4B0veJlrCz84I57EQEqBqdYUZERNRcDDsuRhygrKqzCF5UoO307kqrbqynvjmJ4ooaPPfd6ca7sSyVHXsLC4qzuPxUDYedwTGB+OfsIegW4ivN0LqYVzsjS1Opx/lcrc09gVbt6WvZyuH0NfM1kU5MXSciImouhh0Xo3Mw9bxuZaduNxYA6I0m57ux6oQdncGIGktVydkNOAGgV4S5SnMhv7aycyijGIIAJIT54u4RMVB5yvGn6+Ok81P7R9oMgq67phAREVFrYthxMXUHKIvE7ieR2I0lBhQA8FF5Nhp2pG6sCtturPLq2kpRY5Udaz0toSXNqrJz1LIa8nVxwXj1tgE48fxkdA+rDTdeCg/84+7B0mtxg04iIqK2wLDjYuwNUAYAmUyG75eOkl6LYedqidVeVoIghR21o7Dja78bS5yJ5av0gEcTtmnoaaeyI87OGhQTCA+5zO6+VP2iA/DTI2Pwp+RumDuym9PvR0RE1FQMOy7GUWUHMIcHcdG9Kr05nGQU1a5xU1Cmg6bKdvXkuoIcjNkRByc3NhOrLrGyk1VchaoaIwRBwClL2OkfHdDQregTpcZLt/ZHTLBPk96TiIioKbg3loupDTv294bytuwZJVZ2MgprKzsF5Tpp/ZzGurHqLiqotUw7b8p4HQAI8VMhwFsBTZUemcUV8FWau9IUHjL0irS/OCEREVF7YmXHxUgDlBX2/9P4WsKOOED5WmmVdE5vFJBVbA4/DsOOg0UFy5yciWVPXIi5MpNZVCl1YfWK8HcY2IiIiNoTw46LEfeK8nJY2TGHEbGyU1JnccCMokbCjtSNpZcWIgRqByg3tsaOPbEh5gHGmUUVSLd0q4mztIiIiDoau7FcTGOVHR9LZUfcLqLUzoaeQENTz83HjSbz7ujideLqyc3Zbdy6siPqEujt6HIiIqJ2xcqOi5EWFbQzQBmoDTtiN5a9xQHlMiDWwaBfL4WH9AzrrqyCch0AIMCn6WFHfK/MokpkW7rVugQx7BARkWtg2HExTR2gLG77cF18sHRNQpifdJ094j5UBWU66di5HPPU8d7N6H6Ks6yTk1FUgezSagBANCs7RETkIhh2XIy4zo6Xo24shW1lR6zOTOgdLl0jbsfgiBhErAc3n802b93QL7rhe+3pHuYHuQy4WlKFVMseWezGIiIiV8Gw40IEQWi0suMjDVA2wGSqXURwQmKYdE3XRrqQulqCiFiFKSrXIVdbDZkMSGwkKNkT7KvE4nHdbY5FB3K/KyIicg0MOy6kxli79YOjAcrW3Vjaaj1MlglVCaG1a9oMiQ1q8H1qKzvmAcVnc8xVnbgQ32ZNPQeARyf1tHkthjIiIqKOxrDjQnRW+1w1OkBZb5TG6/gqPaD0lGPzw6Px+h0DMalPuN17ReLgYbGysyO1AAAwqGvDKx43ROXpgfmWzT4DmzHImYiIqK3wn98uRJyJJZMBSo/GKzviTCxxJ/N+0QHo18gWDYBVZaekCkaTgE0nswEAMwZGt6j9y6cnIsRXiestW1oQERG5AoYdFyJtAuoph0xmfzNOX0v3UFVNbWWnqZWULpbxNNmlVThwuQh5Wh3UXp4Y26tlIUXl6YGHJvZs/EIiIqJ2xG4sF9LY4GQA8FWZz5XrDCitMld2xFWRnSVWdsp0Bsz5z0EAwM2Dorm9AxERuSWXDjsvvPACZDKZzVdiYqJ0vrq6GkuXLkVISAj8/Pxw++23Iy8vrwNb3DLiKsaOpp0DQIivCgCgqdIjNbccQNMrOz5KT9w62LbL6p7kbk16BhERUWfh8t1Y/fr1w6+//iq99vSsbfKyZcuwefNmbNiwAQEBAXjwwQcxa9Ys7N27tyOa2mL7LxcBaHidnEAfBZSectQYTHhv5yUAwA2JDQ9Itufvdw7GkJhAfLw/E9fFBSMxsulTzomIiDoDlw87np6eiIyMrHdco9Hgww8/xOeff44bbrgBALB27Vr06dMHBw4cwMiRI9u7qS227Vw+AOCGPhEOr5HJZIhQq5BVbF4QMCHUF7cO7tLk95LLZZg/Kh7zR8U3r7FERESdhEt3YwHAxYsXER0djYSEBMyZMwdXrlwBABw9ehR6vR6TJk2Srk1MTERsbCz279/f4DN1Oh20Wq3NV0crq9bj2JUSAI1XaiLVtQv2Xd8jBB5y+4OZiYiIyMXDTlJSEtatW4ctW7ZgzZo1SE9Px5gxY1BWVobc3FwolUoEBgba3BMREYHc3NwGn7ty5UoEBARIXzExMW34UzinpMK8QKCP0qPRrRbCrcKO9WKCREREVJ9Ld2NNmzZN+n7gwIFISkpCt27d8NVXX8Hbu/l7Ly1fvhyPPfaY9Fqr1XZ44KmoMQBwbuVh68pOQphvm7WJiIjIHbh0ZaeuwMBA9OrVC2lpaYiMjERNTQ1KS0ttrsnLy7M7xseaSqWCWq22+epolZawI04tb0ion0r6vnsYKztEREQN6VRhp7y8HJcuXUJUVBSGDRsGhUKB3377TTqfmpqKK1euIDk5uQNb2TwVOvOCgs5UdgxWe2hxd3EiIqKGuXTYeeKJJ7Bz505kZGRg3759uO222+Dh4YHZs2cjICAACxcuxGOPPYbt27fj6NGjuPfee5GcnNwpZ2KJlR0/Jyo71/cIsVzrCTkHJxMRETXIpcfsXL16FbNnz0ZRURHCwsIwevRoHDhwAGFhYQCAv//975DL5bj99tuh0+kwZcoUrF69uoNb3TzlTajsDOsWjC/uH4n4UI7XISIiaoxLh53169c3eN7Lywvvvvsu3n333XZqUdtpypgdAEjuHtKWzSEiInIbLt2N9XvSlDE7RERE5DyGHRchVXaU3IyTiIioNTHsuAipsqNiZYeIiKg1Mey4CFZ2iIiI2gbDjouoqOGYHSIiorbAsOMiKnVNm41FREREzmHYcRHlOuf3xiIiIiLnMey4iEpLNxYrO0RERK2LYcdFVEgDlFnZISIiak0MOy6iUidWdhh2iIiIWhPDjovQVOkBAD6cek5ERNSqGHZcwMubzqJKz6nnREREbYFhxwWsP3QFANAj3A/h/qoObg0REZF7YdjpYBU6g7Sg4HdLR0Eul3Vwi4iIiNwLw04Hyy/TATBvE+HHwclEREStjmGng+VpqwEA4WqvDm4JERGRe2LY6WBiZYdjdYiIiNoGw04Hy2dlh4iIqE0x7HQwVnaIiIjaFsNOBxMrOxFqhh0iIqK2wLDTwXLFbix/dmMRERG1BYadDrT1bB4OXC4GYF5QkIiIiFofw04H+mR/BgDgnpHd0L9LQMc2hoiIyE0x7LQRQRBwIa8Mnx+8ghqDye4110qrAADTBkS2Z9OIiIh+V7hkbxsRBODO9/ejtFKPvtFqDI4JrHdNnsY8XieS086JiIjaDCs7bUQul2FYbBAA4EhGcb3zZdV6aU+sCIYdIiKiNsOw04aGxYlhp6TeOXGbCH+VJ3y5JxYREVGbYdhpQ8O7BQMAjmSWQBAEm3O5GvNighEBrOoQERG1JYadNjSwawAUHjIUluukwcgisbLD8TpERERti2GnDXkpPNAl0BsAkF1abXMuV1o5mWGHiIioLTHstLFISzdVjsZBZSeA20QQERG1JYadNhYVYK7s5GjqVHY47ZyIiKhdMOy0MbGyk1sn7OSxG4uIiKhdMOy0sSgH3Vi5UjcWww4REVFbYthpY2I3lnVlx2A0oaDMPPWc3VhERERti2GnjdVWdmrDTmF5DUwC4CGXIcSPA5SJiIjaEsNOGxO7qQrKddAZzNtDiF1Y4f4qeMhlHdY2IiKi3wPuU9DGQnyVCPVTorC8BgcuF+P0NQ2q9ebQE84uLCIiojbn0pWdlStXYsSIEfD390d4eDhmzpyJ1NRUm2vGjx8PmUxm8/XAAw90UIvrk8lkGJkQAgCY99EhvP5zKv65LQ0AEKlmFxYREVFbc+mws3PnTixduhQHDhzA1q1bodfrMXnyZFRUVNhcd//99yMnJ0f6eu211zqoxfYldw+xe1wcvExERERtx6W7sbZs2WLzet26dQgPD8fRo0cxduxY6biPjw8iIyPbu3lOG9MjDDIZUGcvUNyQGN4xDSIiIvodcenKTl0ajQYAEBwcbHP8s88+Q2hoKPr374/ly5ejsrKywefodDpotVqbr7YUG+KDTxZch41/vh7je4dJx0f1CG3T9yUiIiIXr+xYM5lMePTRRzFq1Cj0799fOv7HP/4R3bp1Q3R0NE6ePImnn34aqamp+Pbbbx0+a+XKlXjxxRfbo9mSMT3NIWf5tD7IKKzAQzf05EwsIiKidiAThLqdK65pyZIl+Omnn7Bnzx507drV4XXbtm3DxIkTkZaWhu7du9u9RqfTQafTSa+1Wi1iYmKg0WigVqtbve1ERETU+rRaLQICAhr9+7tTVHYefPBBbNq0Cbt27Wow6ABAUlISADQYdlQqFVQqzoQiIiL6PXDpsCMIAh566CFs3LgRO3bsQHx8fKP3pKSkAACioqLauHVERETUGbh02Fm6dCk+//xzfP/99/D390dubi4AICAgAN7e3rh06RI+//xzTJ8+HSEhITh58iSWLVuGsWPHYuDAgR3ceiIiInIFLj1mRyazP4B37dq1mD9/PrKysjB37lycPn0aFRUViImJwW233YZnn322SWNvnO3zIyIiItfhFmN2GsthMTEx2LlzZzu1hoiIiDqjTrXODhEREVFTMewQERGRW2PYISIiIrfGsENERERujWGHiIiI3BrDDhEREbk1hh0iIiJyaww7RERE5NYYdoiIiMitufQKyu1FXKlZq9V2cEuIiIjIWeLf243tuMCwA6CsrAyAefsJIiIi6lzKysoQEBDg8LxLbwTaXkwmE7Kzs+Hv7+9w89Hm0Gq1iImJQVZWFjcYbWP8rNsHP+f2wc+5/fCzbh9t9TkLgoCysjJER0dDLnc8MoeVHQByuRxdu3Zts+er1Wr+IWon/KzbBz/n9sHPuf3ws24fbfE5N1TREXGAMhEREbk1hh0iIiJyaww7bUilUuH555+HSqXq6Ka4PX7W7YOfc/vg59x++Fm3j47+nDlAmYiIiNwaKztERETk1hh2iIiIyK0x7BAREZFbY9ghIiIit8aw04beffddxMXFwcvLC0lJSTh06FBHN6lT2bVrF26++WZER0dDJpPhu+++szkvCAJWrFiBqKgoeHt7Y9KkSbh48aLNNcXFxZgzZw7UajUCAwOxcOFClJeXt+NP4fpWrlyJESNGwN/fH+Hh4Zg5cyZSU1NtrqmursbSpUsREhICPz8/3H777cjLy7O55sqVK5gxYwZ8fHwQHh6OJ598EgaDoT1/FJe2Zs0aDBw4UFpULTk5GT/99JN0np9x21i1ahVkMhkeffRR6Rg/69bxwgsvQCaT2XwlJiZK513qcxaoTaxfv15QKpXCRx99JJw5c0a4//77hcDAQCEvL6+jm9Zp/Pjjj8Jf//pX4dtvvxUACBs3brQ5v2rVKiEgIED47rvvhBMnTgi33HKLEB8fL1RVVUnXTJ06VRg0aJBw4MABYffu3UKPHj2E2bNnt/NP4tqmTJkirF27Vjh9+rSQkpIiTJ8+XYiNjRXKy8ulax544AEhJiZG+O2334QjR44II0eOFK6//nrpvMFgEPr37y9MmjRJOH78uPDjjz8KoaGhwvLlyzviR3JJ//vf/4TNmzcLFy5cEFJTU4W//OUvgkKhEE6fPi0IAj/jtnDo0CEhLi5OGDhwoPDII49Ix/lZt47nn39e6Nevn5CTkyN9FRQUSOdd6XNm2Gkj1113nbB06VLptdFoFKKjo4WVK1d2YKs6r7phx2QyCZGRkcLrr78uHSstLRVUKpXwxRdfCIIgCGfPnhUACIcPH5au+emnnwSZTCZcu3at3dre2eTn5wsAhJ07dwqCYP5cFQqFsGHDBumac+fOCQCE/fv3C4JgDqZyuVzIzc2VrlmzZo2gVqsFnU7Xvj9AJxIUFCT85z//4WfcBsrKyoSePXsKW7duFcaNGyeFHX7Wref5558XBg0aZPecq33O7MZqAzU1NTh69CgmTZokHZPL5Zg0aRL279/fgS1zH+np6cjNzbX5jAMCApCUlCR9xvv370dgYCCGDx8uXTNp0iTI5XIcPHiw3dvcWWg0GgBAcHAwAODo0aPQ6/U2n3ViYiJiY2NtPusBAwYgIiJCumbKlCnQarU4c+ZMO7a+czAajVi/fj0qKiqQnJzMz7gNLF26FDNmzLD5TAH+/9zaLl68iOjoaCQkJGDOnDm4cuUKANf7nLkRaBsoLCyE0Wi0+Q8IABERETh//nwHtcq95ObmAoDdz1g8l5ubi/DwcJvznp6eCA4Olq4hWyaTCY8++ihGjRqF/v37AzB/jkqlEoGBgTbX1v2s7f23EM+R2alTp5CcnIzq6mr4+flh48aN6Nu3L1JSUvgZt6L169fj2LFjOHz4cL1z/P+59SQlJWHdunXo3bs3cnJy8OKLL2LMmDE4ffq0y33ODDtEJFm6dClOnz6NPXv2dHRT3FLv3r2RkpICjUaDr7/+GvPmzcPOnTs7ulluJSsrC4888gi2bt0KLy+vjm6OW5s2bZr0/cCBA5GUlIRu3brhq6++gre3dwe2rD52Y7WB0NBQeHh41Bt1npeXh8jIyA5qlXsRP8eGPuPIyEjk5+fbnDcYDCguLuZ/BzsefPBBbNq0Cdu3b0fXrl2l45GRkaipqUFpaanN9XU/a3v/LcRzZKZUKtGjRw8MGzYMK1euxKBBg/CPf/yDn3ErOnr0KPLz8zF06FB4enrC09MTO3fuxDvvvANPT09ERETws24jgYGB6NWrF9LS0lzu/2mGnTagVCoxbNgw/Pbbb9Ixk8mE3377DcnJyR3YMvcRHx+PyMhIm89Yq9Xi4MGD0mecnJyM0tJSHD16VLpm27ZtMJlMSEpKavc2uypBEPDggw9i48aN2LZtG+Lj423ODxs2DAqFwuazTk1NxZUrV2w+61OnTtmEy61bt0KtVqNv377t84N0QiaTCTqdjp9xK5o4cSJOnTqFlJQU6Wv48OGYM2eO9D0/67ZRXl6OS5cuISoqyvX+n27V4c4kWb9+vaBSqYR169YJZ8+eFRYtWiQEBgbajDqnhpWVlQnHjx8Xjh8/LgAQ3nrrLeH48eNCZmamIAjmqeeBgYHC999/L5w8eVK49dZb7U49HzJkiHDw4EFhz549Qs+ePTn1vI4lS5YIAQEBwo4dO2ymkFZWVkrXPPDAA0JsbKywbds24ciRI0JycrKQnJwsnRenkE6ePFlISUkRtmzZIoSFhXGqrpVnnnlG2Llzp5Ceni6cPHlSeOaZZwSZTCb88ssvgiDwM25L1rOxBIGfdWt5/PHHhR07dgjp6enC3r17hUmTJgmhoaFCfn6+IAiu9Tkz7LShf/7zn0JsbKygVCqF6667Tjhw4EBHN6lT2b59uwCg3te8efMEQTBPP3/uueeEiIgIQaVSCRMnThRSU1NtnlFUVCTMnj1b8PPzE9RqtXDvvfcKZWVlHfDTuC57nzEAYe3atdI1VVVVwp///GchKChI8PHxEW677TYhJyfH5jkZGRnCtGnTBG9vbyE0NFR4/PHHBb1e384/jetasGCB0K1bN0GpVAphYWHCxIkTpaAjCPyM21LdsMPPunXcddddQlRUlKBUKoUuXboId911l5CWliadd6XPWSYIgtC6tSIiIiIi18ExO0REROTWGHaIiIjIrTHsEBERkVtj2CEiIiK3xrBDREREbo1hh4iIiNwaww4RERG5NYYdIuo0MjIyIJPJkJKS0mbvMX/+fMycObPNnk9E7Y9hh4jazfz58yGTyep9TZ061an7Y2JikJOTg/79+7dxS4nInXh2dAOI6Pdl6tSpWLt2rc0xlUrl1L0eHh7cdZqImoyVHSJqVyqVCpGRkTZfQUFBAACZTIY1a9Zg2rRp8Pb2RkJCAr7++mvp3rrdWCUlJZgzZw7CwsLg7e2Nnj172gSpU6dO4YYbboC3tzdCQkKwaNEilJeXS+eNRiMee+wxBAYGIiQkBE899RTq7qBjMpmwcuVKxMfHw9vbG4MGDbJpU2NtIKKOx7BDRC7lueeew+23344TJ05gzpw5uPvuu3Hu3DmH1549exY//fQTzp07hzVr1iA0NBQAUFFRgSlTpiAoKAiHDx/Ghg0b8Ouvv+LBBx+U7n/zzTexbt06fPTRR9izZw+Ki4uxceNGm/dYuXIlPvnkE7z33ns4c+YMli1bhrlz52Lnzp2NtoGIXESrby1KROTAvHnzBA8PD8HX19fm69VXXxUEwbwD+wMPPGBzT1JSkrBkyRJBEAQhPT1dACAcP35cEARBuPnmm4V7773X7nt98MEHQlBQkFBeXi4d27x5syCXy4Xc3FxBEAQhKipKeO2116Tzer1e6Nq1q3DrrbcKgiAI1dXVgo+Pj7Bv3z6bZy9cuFCYPXt2o20gItfAMTtE1K4mTJiANWvW2BwLDg6Wvk9OTrY5l5yc7HD21ZIlS3D77bfj2LFjmDx5MmbOnInrr78eAHDu3DkMGjQIvr6+0vWjRo2CyWRCamoqvLy8kJOTg6SkJOm8p6cnhg8fLnVlpaWlobKyEjfeeKPN+9bU1GDIkCGNtoGIXAPDDhG1K19fX/To0aNVnjVt2jRkZmbixx9/xNatWzFx4kQsXboUb7zxRqs8Xxzfs3nzZnTp0sXmnDiouq3bQEQtxzE7RORSDhw4UO91nz59HF4fFhaGefPm4b///S/efvttfPDBBwCAPn364MSJE6ioqJCu3bt3L+RyOXr37o2AgABERUXh4MGD0nmDwYCjR49Kr/v27QuVSoUrV66gR48eNl8xMTGNtoGIXAMrO0TUrnQ6HXJzc22OeXp6SoN6N2zYgOHDh2P06NH47LPPcOjQIXz44Yd2n7VixQoMGzYM/fr1g06nw6ZNm6RgNGfOHDz//POYN28eXnjhBRQUFOChhx7CPffcg4iICADAI488glWrVqFnz55ITEzEW2+9hdLSUun5/v7+eOKJJ7Bs2TKYTCaMHj0aGo0Ge/fuhVqtxrx58xpsAxG5BoYdImpXW7ZsQVRUlM2x3r174/z58wCAF198EevXr8ef//xnREVF4YsvvkDfvn3tPkupVGL58uXIyMiAt7c3xowZg/Xr1wMAfHx88PPPP+ORRx7BiBEj4OPjg9tvvx1vvfWWdP/jjz+OnJwczJs3D3K5HAsWLMBtt90GjUYjXfPyyy8jLCwMK1euxOXLlxEYGIihQ4fiL3/5S6NtICLXIBOEOotKEBF1EJlMho0bN3K7BiJqVRyzQ0RERG6NYYeIiIjcGsfsEJHLYK86EbUFVnaIiIjIrTHsEBERkVtj2CEiIiK3xrBDREREbo1hh4iIiNwaww4RERG5NYYdIiIicmsMO0REROTWGHaIiIjIrf0/fV2L9f825osAAAAASUVORK5CYII="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_episodes = 500\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "lmbda = 0.95\n",
    "critic_lr = 1e-2\n",
    "kl_constraint = 0.0005\n",
    "alpha = 0.5\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'CartPole-v0'\n",
    "env = gym.make(env_name)\n",
    "env.seed(0)\n",
    "torch.manual_seed(0)\n",
    "agent = TRPO(hidden_dim, env.observation_space, env.action_space, lmbda,\n",
    "             kl_constraint, alpha, critic_lr, gamma, device)\n",
    "return_list = rl_utils.train_on_policy_agent(env, agent, num_episodes)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('TRPO on {}'.format(env_name))\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-07-07T10:45:15.221724Z",
     "end_time": "2023-07-07T10:47:46.644668Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
